@tsslint/cli 1.3.6 → 1.4.1

package/index.js

@@ -3,147 +3,313 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ts = require("typescript");
 const path = require("path");
 const core = require("@tsslint/core");
-const cache = require("./lib/cache");
+const cache = require("./lib/cache.js");
+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;
 const lightRed = (s) => '\x1b[91m' + s + _reset;
 const lightGreen = (s) => '\x1b[92m' + s + _reset;
 const lightYellow = (s) => '\x1b[93m' + s + _reset;
+let threads = 1;
+if (process.argv.includes('--threads')) {
+    const threadsIndex = process.argv.indexOf('--threads');
+    const threadsArg = process.argv[threadsIndex + 1];
+    if (!threadsArg || threadsArg.startsWith('-')) {
+        console.error(lightRed(`Missing argument for --threads.`));
+        process.exit(1);
+    }
+    threads = Math.min(os.availableParallelism(), Number(threadsArg));
+}
+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 () => {
-    let hasError = false;
-    let projectVersion = 0;
-    let typeRootsVersion = 0;
-    let parsed;
+    const builtConfigs = new Map();
     const clack = await import('@clack/prompts');
-    const snapshots = new Map();
-    const versions = new Map();
-    const configs = new Map();
-    const languageServiceHost = {
-        ...ts.sys,
-        useCaseSensitiveFileNames() {
-            return ts.sys.useCaseSensitiveFileNames;
-        },
-        getProjectVersion() {
-            return projectVersion.toString();
-        },
-        getTypeRootsVersion() {
-            return typeRootsVersion;
-        },
-        getCompilationSettings() {
-            return parsed.options;
-        },
-        getScriptFileNames() {
-            return parsed.fileNames;
-        },
-        getScriptVersion(fileName) {
-            return versions.get(fileName)?.toString() ?? '0';
-        },
-        getScriptSnapshot(fileName) {
-            if (!snapshots.has(fileName)) {
-                snapshots.set(fileName, ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName)));
+    const processFiles = new Set();
+    let projects = [];
+    let spinner = clack.spinner();
+    let lastSpinnerUpdate = Date.now();
+    let hasFix = false;
+    let allFilesNum = 0;
+    let processed = 0;
+    let excluded = 0;
+    let passed = 0;
+    let errors = 0;
+    let warnings = 0;
+    let cached = 0;
+    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);
+        }
+        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);
+        }
+        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];
+            }
+            else {
+                command += ' --projects ' + selectedTsconfigs.join(' ');
             }
-            return snapshots.get(fileName);
-        },
-        getDefaultLibFileName(options) {
-            return ts.getDefaultLibFilePath(options);
-        },
-    };
-    const languageService = ts.createLanguageService(languageServiceHost);
-    if (process.argv.includes('--project')) {
-        const projectIndex = process.argv.indexOf('--project');
-        let tsconfig = process.argv[projectIndex + 1];
-        if (tsconfig.startsWith('-') || !tsconfig) {
-            clack.log.error(lightRed(`Missing argument for --project.`));
         }
         else {
+            for (const language of languages) {
+                if (selectedTsconfigs.length === 1) {
+                    command += ` --${language}-project ` + selectedTsconfigs[0];
+                }
+                else {
+                    command += ` --${language}-projects ` + selectedTsconfigs.join(' ');
+                }
+            }
+        }
+        clack.log.info(`Running: ${purple(command)}`);
+        for (let tsconfig of selectedTsconfigs) {
             if (!tsconfig.startsWith('.')) {
                 tsconfig = `./${tsconfig}`;
             }
-            await projectWorker(tsconfig);
+            tsconfigAndLanguages.set(tsconfig, languages);
         }
     }
-    else if (process.argv.includes('--projects')) {
-        const projectsIndex = process.argv.indexOf('--projects');
-        for (let i = projectsIndex + 1; i < process.argv.length; i++) {
-            if (process.argv[i].startsWith('-')) {
-                break;
-            }
-            const searchGlob = process.argv[i];
-            const tsconfigs = glob.sync(searchGlob);
-            for (let tsconfig of tsconfigs) {
+    else {
+        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}`;
                 }
-                await projectWorker(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) {
+        project.builtConfig = await getBuiltConfig(project.configFile);
+    }
+    projects = projects.filter(project => !!project.builtConfig);
+    for (const project of projects) {
+        allFilesNum += project.fileNames.length;
+    }
+    if (allFilesNum === 0) {
+        spinner.stop(lightYellow('No input files.'));
+        process.exit(1);
+    }
+    if (threads === 1) {
+        await startWorker(worker.createLocal());
+    }
     else {
-        const tsconfig = await askTSConfig();
-        await projectWorker(tsconfig);
+        await Promise.all(new Array(threads).fill(0).map(() => {
+            return startWorker(worker.create());
+        }));
+    }
+    spinner.stop(darkGray(cached
+        ? `Processed ${processed} files with cache. (Use --force to ignore cache.)`
+        : `Processed ${processed} files.`));
+    const data = [
+        [passed, 'passed', lightGreen],
+        [errors, 'errors', lightRed],
+        [warnings, 'warnings', lightYellow],
+        [excluded, 'excluded', darkGray],
+    ];
+    let summary = data
+        .filter(([count]) => count)
+        .map(([count, label, color]) => color(`${count} ${label}`))
+        .join(darkGray(' | '));
+    if (hasFix) {
+        summary += darkGray(` (Use --fix to apply automatic fixes.)`);
     }
-    process.exit(hasError ? 1 : 0);
-    async function projectWorker(tsconfigOption) {
-        const tsconfig = require.resolve(tsconfigOption, { paths: [process.cwd()] });
-        clack.intro(`${purple('[project]')} ${path.relative(process.cwd(), tsconfig)}`);
-        parsed = parseCommonLine(tsconfig);
-        if (!parsed.fileNames.length) {
-            clack.outro(lightYellow('No included files.'));
+    else if (errors || warnings) {
+        summary += darkGray(` (No fixes available.)`);
+    }
+    clack.outro(summary);
+    process.exit(errors ? 1 : 0);
+    async function startWorker(linterWorker) {
+        const unfinishedProjects = projects.filter(project => project.currentFileIndex < project.fileNames.length);
+        if (!unfinishedProjects.length) {
             return;
         }
-        const configFile = ts.findConfigFile(path.dirname(tsconfig), ts.sys.fileExists, 'tsslint.config.ts');
-        if (!configFile) {
-            clack.outro(lightYellow('No tsslint.config.ts found.'));
-            return;
+        // Select a project that has not has a worker yet
+        let project = unfinishedProjects.find(project => !project.workers.length);
+        if (!project) {
+            // Choose a project with the most files left per worker
+            project = unfinishedProjects.sort((a, b) => {
+                const aFilesPerWorker = (a.fileNames.length - a.currentFileIndex) / a.workers.length;
+                const bFilesPerWorker = (b.fileNames.length - b.currentFileIndex) / b.workers.length;
+                return bFilesPerWorker - aFilesPerWorker;
+            })[0];
         }
-        if (!configs.has(configFile)) {
-            try {
-                configs.set(configFile, await core.buildConfigFile(configFile, ts.sys.createHash, clack));
-            }
-            catch (err) {
-                configs.set(configFile, undefined);
-                console.error(err);
-            }
-        }
-        const tsslintConfig = configs.get(configFile);
-        if (!tsslintConfig) {
+        project.workers.push(linterWorker);
+        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);
             return;
         }
-        projectVersion++;
-        typeRootsVersion++;
-        const lintCache = process.argv.includes('--force')
-            ? {}
-            : cache.loadCache(configFile, ts.sys.createHash);
-        const projectContext = {
-            configFile,
-            languageService,
-            languageServiceHost,
-            typescript: ts,
-            tsconfig: ts.server.toNormalizedPath(tsconfig),
-        };
-        const linter = core.createLinter(projectContext, tsslintConfig, 'cli', clack);
-        let lintSpinner = clack.spinner();
-        let hasFix = false;
-        let excluded = 0;
-        let passed = 0;
-        let errors = 0;
-        let warnings = 0;
-        let cached = 0;
-        let t = Date.now();
-        lintSpinner.start(darkGray(`[1/${parsed.fileNames.length}] ${path.relative(process.cwd(), parsed.fileNames[0])}`));
-        await new Promise(resolve => setTimeout(resolve, 100));
-        for (let i = 0; i < parsed.fileNames.length; i++) {
-            const fileName = parsed.fileNames[i];
-            if (Date.now() - t > 100) {
-                t = Date.now();
-                lintSpinner.message(darkGray(`[${i + 1}/${parsed.fileNames.length}] ${path.relative(process.cwd(), fileName)}`));
+        while (project.currentFileIndex < project.fileNames.length) {
+            const i = project.currentFileIndex++;
+            const fileName = project.fileNames[i];
+            const fileMtime = fs.statSync(fileName).mtimeMs;
+            addProcessFile(fileName);
+            if (Date.now() - lastSpinnerUpdate > 100) {
+                lastSpinnerUpdate = Date.now();
                 await new Promise(resolve => setTimeout(resolve, 0));
             }
-            const fileMtime = fs.statSync(fileName).mtimeMs;
-            let fileCache = lintCache[fileName];
+            let fileCache = project.cache[fileName];
             if (fileCache) {
                 if (fileCache[0] !== fileMtime) {
                     fileCache[0] = fileMtime;
@@ -157,48 +323,17 @@ const lightYellow = (s) => '\x1b[93m' + s + _reset;
                 }
             }
             else {
-                lintCache[fileName] = fileCache = [fileMtime, {}, [], [], {}];
+                project.cache[fileName] = fileCache = [fileMtime, {}, [], [], {}];
             }
             let diagnostics;
             if (process.argv.includes('--fix')) {
-                let retry = 3;
-                let shouldRetry = true;
-                let newSnapshot;
-                while (shouldRetry && retry) {
-                    shouldRetry = false;
-                    retry--;
-                    if (Object.values(fileCache[1]).some(fixes => fixes > 0)) {
-                        // Reset the cache if there are any fixes applied.
-                        fileCache[1] = {};
-                        fileCache[2].length = 0;
-                        fileCache[3].length = 0;
-                    }
-                    diagnostics = linter.lint(fileName, fileCache);
-                    const fixes = linter.getCodeFixes(fileName, 0, Number.MAX_VALUE, diagnostics, fileCache);
-                    const textChanges = core.combineCodeFixes(fileName, fixes);
-                    if (textChanges.length) {
-                        const oldSnapshot = snapshots.get(fileName);
-                        newSnapshot = core.applyTextChanges(oldSnapshot, textChanges);
-                        snapshots.set(fileName, newSnapshot);
-                        versions.set(fileName, (versions.get(fileName) ?? 0) + 1);
-                        projectVersion++;
-                        shouldRetry = true;
-                    }
-                }
-                if (newSnapshot) {
-                    ts.sys.writeFile(fileName, newSnapshot.getText(0, newSnapshot.getLength()));
-                    fileCache[0] = fs.statSync(fileName).mtimeMs;
-                }
-                if (shouldRetry) {
-                    diagnostics = linter.lint(fileName, fileCache);
-                }
+                diagnostics = await linterWorker.lintAndFix(fileName, fileCache);
             }
             else {
-                diagnostics = linter.lint(fileName, fileCache);
+                diagnostics = await linterWorker.lint(fileName, fileCache);
             }
             if (diagnostics.length) {
-                hasFix ||= linter.hasCodeFixes(fileName);
-                hasError ||= diagnostics.some(diagnostic => diagnostic.category === ts.DiagnosticCategory.Error);
+                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;
@@ -209,96 +344,64 @@ const lightYellow = (s) => '\x1b[93m' + s + _reset;
                         getNewLine: () => ts.sys.newLine,
                     });
                     output = output.replace(`TS${diagnostic.code}`, String(diagnostic.code));
-                    if (lintSpinner) {
-                        if (diagnostic.category === ts.DiagnosticCategory.Error) {
-                            errors++;
-                            lintSpinner.stop(output, 1);
-                        }
-                        else if (diagnostic.category === ts.DiagnosticCategory.Warning) {
-                            warnings++;
-                            lintSpinner.stop(output, 2);
-                        }
-                        else {
-                            lintSpinner.stop(output);
-                        }
-                        lintSpinner = undefined;
+                    if (diagnostic.category === ts.DiagnosticCategory.Error) {
+                        errors++;
+                        log(output, 1);
+                    }
+                    else if (diagnostic.category === ts.DiagnosticCategory.Warning) {
+                        warnings++;
+                        log(output, 2);
                     }
                     else {
-                        if (diagnostic.category === ts.DiagnosticCategory.Error) {
-                            errors++;
-                            clack.log.error(output);
-                        }
-                        else if (diagnostic.category === ts.DiagnosticCategory.Warning) {
-                            warnings++;
-                            clack.log.warning(output);
-                        }
-                        else {
-                            clack.log.info(output);
-                        }
+                        log(output);
                     }
                 }
             }
-            else if (!Object.keys(linter.getRules(fileName, fileCache)).length) {
+            else if (!(await linterWorker.hasRules(fileName, fileCache[4]))) {
                 excluded++;
             }
             else {
                 passed++;
             }
-            if (!lintSpinner) {
-                lintSpinner = clack.spinner();
-                lintSpinner.start(darkGray(`[${i + 1}/${parsed.fileNames.length}] ${path.relative(process.cwd(), parsed.fileNames[i])}`));
-                await new Promise(resolve => setTimeout(resolve, 100));
-            }
-        }
-        if (cached) {
-            lintSpinner.stop(darkGray(`Processed ${parsed.fileNames.length} files with cache. (Use --force to ignore cache.)`));
-        }
-        else {
-            lintSpinner.stop(darkGray(`Processed ${parsed.fileNames.length} files.`));
-        }
-        const data = [
-            [passed, 'passed', lightGreen],
-            [errors, 'errors', lightRed],
-            [warnings, 'warnings', lightYellow],
-            [excluded, 'excluded', darkGray],
-        ];
-        let summary = data
-            .filter(([count]) => count)
-            .map(([count, label, color]) => color(`${count} ${label}`))
-            .join(darkGray(' | '));
-        if (hasFix) {
-            summary += darkGray(` (Use --fix to apply automatic fixes.)`);
+            processed++;
+            removeProcessFile(fileName);
         }
-        else if (errors || warnings) {
-            summary += darkGray(` (No fixes available.)`);
+        cache.saveCache(project.tsconfig, project.configFile, project.cache, ts.sys.createHash);
+        await startWorker(linterWorker);
+    }
+    async function getBuiltConfig(configFile) {
+        if (!builtConfigs.has(configFile)) {
+            builtConfigs.set(configFile, core.buildConfig(configFile, ts.sys.createHash, spinner, (s, code) => log(darkGray(s), code)));
         }
-        clack.outro(summary);
-        cache.saveCache(configFile, lintCache, ts.sys.createHash);
+        return await builtConfigs.get(configFile);
+    }
+    function addProcessFile(fileName) {
+        processFiles.add(fileName);
+        updateSpinner();
     }
-    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}`;
+    function removeProcessFile(fileName) {
+        processFiles.delete(fileName);
+        updateSpinner();
+    }
+    function updateSpinner() {
+        if (processFiles.size === 1) {
+            const fileName = processFiles.values().next().value;
+            spinner.message(`[${processed + processFiles.size}/${allFilesNum}] ${path.relative(process.cwd(), fileName)}`);
+        }
+        else {
+            spinner.message(`[${processed + processFiles.size}/${allFilesNum}] Processing ${processFiles.size} files`);
         }
-        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 log(msg, code) {
+        spinner.stop(msg, code);
+        spinner = clack.spinner();
+        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/cache.d.ts

@@ -1,4 +1,4 @@
 import core = require('@tsslint/core');
 export type CacheData = Record<string, core.FileLintCache>;
-export declare function loadCache(configFilePath: string, createHash?: (path: string) => string): CacheData;
-export declare function saveCache(configFilePath: string, cache: CacheData, createHash?: (path: string) => string): void;
+export declare function loadCache(tsconfig: string, configFilePath: string, createHash?: (path: string) => string): CacheData;
+export declare function saveCache(tsconfig: string, configFilePath: string, cache: CacheData, createHash?: (path: string) => string): void;

package/lib/cache.js

@@ -5,9 +5,9 @@ exports.saveCache = saveCache;
 const core = require("@tsslint/core");
 const path = require("path");
 const fs = require("fs");
-function loadCache(configFilePath, createHash = btoa) {
+function loadCache(tsconfig, configFilePath, createHash = btoa) {
     const outDir = core.getDotTsslintPath(configFilePath);
-    const cacheFileName = createHash(path.relative(outDir, configFilePath)) + '.cache.json';
+    const cacheFileName = createHash(path.relative(outDir, configFilePath)) + '_' + createHash(path.relative(outDir, tsconfig)) + '.cache.json';
     const cacheFilePath = path.join(outDir, cacheFileName);
     const cacheFileStat = fs.statSync(cacheFilePath, { throwIfNoEntry: false });
     const configFileStat = fs.statSync(configFilePath, { throwIfNoEntry: false });
@@ -21,9 +21,9 @@ function loadCache(configFilePath, createHash = btoa) {
     }
     return {};
 }
-function saveCache(configFilePath, cache, createHash = btoa) {
+function saveCache(tsconfig, configFilePath, cache, createHash = btoa) {
     const outDir = core.getDotTsslintPath(configFilePath);
-    const cacheFileName = createHash(path.relative(outDir, configFilePath)) + '.cache.json';
+    const cacheFileName = createHash(path.relative(outDir, configFilePath)) + '_' + createHash(path.relative(outDir, tsconfig)) + '.cache.json';
     const cacheFilePath = path.join(outDir, cacheFileName);
     fs.writeFileSync(cacheFilePath, JSON.stringify(cache));
 }

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

@@ -0,0 +1,22 @@
+import ts = require('typescript');
+import core = require('@tsslint/core');
+export declare function createLocal(): {
+    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>): boolean;
+};
+export declare function create(): {
+    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, 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;
+declare function hasRules(fileName: string, minimatchCache: core.FileLintCache[4]): readonly [boolean, Record<string, boolean>];
+export {};

package/lib/worker.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocal = createLocal;
+exports.create = create;
+const ts = require("typescript");
+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 originalHost = {
+    ...ts.sys,
+    useCaseSensitiveFileNames() {
+        return ts.sys.useCaseSensitiveFileNames;
+    },
+    getProjectVersion() {
+        return projectVersion.toString();
+    },
+    getTypeRootsVersion() {
+        return typeRootsVersion;
+    },
+    getCompilationSettings() {
+        return options;
+    },
+    getScriptFileNames() {
+        return fileNames;
+    },
+    getScriptVersion(fileName) {
+        return versions.get(fileName)?.toString() ?? '0';
+    },
+    getScriptSnapshot(fileName) {
+        if (!snapshots.has(fileName)) {
+            snapshots.set(fileName, ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName)));
+        }
+        return snapshots.get(fileName);
+    },
+    getDefaultLibFileName(options) {
+        return ts.getDefaultLibFilePath(options);
+    },
+};
+const linterHost = { ...originalHost };
+const originalService = ts.createLanguageService(linterHost);
+function createLocal() {
+    return {
+        setup(...args) {
+            return setup(...args);
+        },
+        lint(...args) {
+            return lint(...args)[0];
+        },
+        lintAndFix(...args) {
+            return lintAndFix(...args)[0];
+        },
+        hasCodeFixes(...args) {
+            return hasCodeFixes(...args);
+        },
+        hasRules(...args) {
+            return hasRules(...args)[0];
+        },
+    };
+}
+function create() {
+    const worker = new worker_threads.Worker(__filename);
+    return {
+        setup(...args) {
+            return sendRequest(setup, ...args);
+        },
+        async lint(...args) {
+            const [res, newCache] = await sendRequest(lint, ...args);
+            Object.assign(args[1], newCache); // Sync the cache
+            return res;
+        },
+        async lintAndFix(...args) {
+            const [res, newCache] = await sendRequest(lintAndFix, ...args);
+            Object.assign(args[1], newCache); // Sync the cache
+            return res;
+        },
+        hasCodeFixes(...args) {
+            return sendRequest(hasCodeFixes, ...args);
+        },
+        async hasRules(...args) {
+            const [res, newCache] = await sendRequest(hasRules, ...args);
+            Object.assign(args[1], newCache); // Sync the cache
+            return res;
+        },
+    };
+    function sendRequest(t, ...args) {
+        return new Promise(resolve => {
+            worker.once('message', json => {
+                resolve(JSON.parse(json));
+            });
+            worker.postMessage(JSON.stringify([t.name, ...args]));
+        });
+    }
+}
+worker_threads.parentPort?.on('message', async (json) => {
+    const data = JSON.parse(json);
+    const result = await handlers[data[0]](...data.slice(1));
+    worker_threads.parentPort.postMessage(JSON.stringify(result));
+});
+const handlers = {
+    setup,
+    lint,
+    lintAndFix,
+    hasCodeFixes,
+    hasRules,
+};
+async function setup(tsconfig, languages, configFile, builtConfig, _fileNames, _options) {
+    const clack = await import('@clack/prompts');
+    let config;
+    try {
+        config = (await import(url.pathToFileURL(builtConfig).toString())).default;
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            clack.log.error(err.stack ?? err.message);
+        }
+        else {
+            clack.log.error(String(err));
+        }
+        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;
+    linter = core.createLinter({
+        configFile,
+        languageService: linterLanguageService,
+        languageServiceHost: linterHost,
+        typescript: ts,
+        tsconfig: ts.server.toNormalizedPath(tsconfig),
+    }, config, 'cli', clack);
+    return true;
+}
+function lintAndFix(fileName, fileCache) {
+    let retry = 1;
+    let shouldRetry = true;
+    let newSnapshot;
+    let diagnostics;
+    while (shouldRetry && retry--) {
+        if (Object.values(fileCache[1]).some(fixes => fixes > 0)) {
+            // Reset the cache if there are any fixes applied.
+            fileCache[1] = {};
+            fileCache[2].length = 0;
+            fileCache[3].length = 0;
+        }
+        diagnostics = linter.lint(fileName, fileCache);
+        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);
+            newSnapshot = core.applyTextChanges(oldSnapshot, textChanges);
+            snapshots.set(fileName, newSnapshot);
+            versions.set(fileName, (versions.get(fileName) ?? 0) + 1);
+            projectVersion++;
+            shouldRetry = true;
+        }
+    }
+    if (newSnapshot) {
+        ts.sys.writeFile(fileName, newSnapshot.getText(0, newSnapshot.getLength()));
+        fileCache[0] = fs.statSync(fileName).mtimeMs;
+        fileCache[1] = {};
+        fileCache[2].length = 0;
+        fileCache[3].length = 0;
+    }
+    if (shouldRetry) {
+        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,
+                text: diagnostic.file.text,
+            },
+            relatedInformation: diagnostic.relatedInformation?.map(info => ({
+                ...info,
+                file: info.file ? {
+                    fileName: info.file.fileName,
+                    text: info.file.text,
+                } : undefined,
+            })),
+        }));
+    }
+    return [diagnostics, fileCache];
+}
+function lint(fileName, fileCache) {
+    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,
+                text: diagnostic.file.text,
+            },
+            relatedInformation: diagnostic.relatedInformation?.map(info => ({
+                ...info,
+                file: info.file ? {
+                    fileName: info.file.fileName,
+                    text: info.file.text,
+                } : undefined,
+            })),
+        }));
+    }
+    return [diagnostics, fileCache];
+}
+function getFileText(fileName) {
+    return originalHost.getScriptSnapshot(fileName).getText(0, Number.MAX_VALUE);
+}
+function hasCodeFixes(fileName) {
+    return linter.hasCodeFixes(fileName);
+}
+function hasRules(fileName, minimatchCache) {
+    return [Object.keys(linter.getRules(fileName, minimatchCache)).length > 0, minimatchCache];
+}
+//# sourceMappingURL=worker.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/cli",
-	"version": "1.3.6",
+	"version": "1.4.1",
 	"license": "MIT",
 	"bin": {
 		"tsslint": "./bin/tsslint.js"
@@ -16,12 +16,17 @@
 	},
 	"dependencies": {
 		"@clack/prompts": "^0.8.2",
-		"@tsslint/config": "1.3.6",
-		"@tsslint/core": "1.3.6",
+		"@tsslint/config": "1.4.1",
+		"@tsslint/core": "1.4.1",
+		"@volar/language-core": "~2.4.0",
+		"@volar/typescript": "~2.4.0",
 		"glob": "^10.4.1"
 	},
 	"peerDependencies": {
 		"typescript": "*"
 	},
-	"gitHead": "d153aa87c92803b4c20fef1f5cf2799f1a599099"
+	"devDependencies": {
+		"@vue/language-core": "latest"
+	},
+	"gitHead": "54f42ec9414029a356fa19a762260f03392563fa"
 }