@tsslint/cli 1.3.5 → 1.4.0

package/index.js

@@ -3,139 +3,187 @@ 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 gray = '\x1b[90m';
-const purple = '\x1b[35m';
-const green = '\x1b[32m';
-const red = '\x1b[31m';
-const yellow = '\x1b[33m';
-const reset = '\x1b[0m';
+const os = require("os");
+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));
+}
 (async () => {
-    let hasError = false;
-    let projectVersion = 0;
-    let typeRootsVersion = 0;
-    let parsed;
-    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)));
+    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);
             }
-            return snapshots.get(fileName);
-        },
-        getDefaultLibFileName(options) {
-            return ts.getDefaultLibFilePath(options);
-        },
-    };
-    const languageService = ts.createLanguageService(languageServiceHost);
+        }
+    }
+    const builtConfigs = new Map();
+    const clack = await import('@clack/prompts');
+    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;
+    spinner.start();
     if (process.argv.includes('--project')) {
         const projectIndex = process.argv.indexOf('--project');
-        const tsconfig = process.argv[projectIndex + 1];
-        await projectWorker(tsconfig);
+        let tsconfig = process.argv[projectIndex + 1];
+        if (!tsconfig || tsconfig.startsWith('-')) {
+            console.error(lightRed(`Missing argument for --project.`));
+            process.exit(1);
+        }
+        if (!tsconfig.startsWith('.')) {
+            tsconfig = `./${tsconfig}`;
+        }
+        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;
             }
+            foundArg = true;
             const searchGlob = process.argv[i];
             const tsconfigs = glob.sync(searchGlob);
             for (let tsconfig of tsconfigs) {
                 if (!tsconfig.startsWith('.')) {
                     tsconfig = `./${tsconfig}`;
                 }
-                await projectWorker(tsconfig);
+                projects.push(new Project(tsconfig));
             }
         }
+        if (!foundArg) {
+            console.error(lightRed(`Missing argument for --projects.`));
+            process.exit(1);
+        }
     }
     else {
-        await projectWorker();
+        const tsconfig = await askTSConfig();
+        projects.push(new Project(tsconfig));
     }
-    process.exit(hasError ? 1 : 0);
-    async function projectWorker(tsconfigOption) {
-        const tsconfig = await getTsconfigPath(tsconfigOption);
-        clack.intro(`${purple}[project]${reset} ${path.relative(process.cwd(), tsconfig)}`);
-        parsed = parseCommonLine(tsconfig);
-        if (!parsed.fileNames.length) {
-            clack.outro(`${yellow}No input files found.${reset}`);
-            return;
-        }
-        const configFile = ts.findConfigFile(path.dirname(tsconfig), ts.sys.fileExists, 'tsslint.config.ts');
-        if (!configFile) {
-            clack.outro(`${yellow}No tsslint.config.ts found!${reset}`);
+    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 {
+        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.)`);
+    }
+    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;
         }
-        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);
-            }
+        // 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];
         }
-        const tsslintConfig = configs.get(configFile);
-        if (!tsslintConfig) {
+        project.workers.push(linterWorker);
+        const setupSuccess = await linterWorker.setup(project.tsconfig, project.configFile, project.builtConfig, project.fileNames, project.options);
+        if (!setupSuccess) {
+            projects = projects.filter(p => p !== project);
+            startWorker(linterWorker);
             return;
         }
-        if (!parsed.fileNames) {
-            throw new Error('No input files found in tsconfig!');
-        }
-        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);
-        const lintSpinner = clack.spinner();
-        let hasFix = false;
-        let passed = 0;
-        let errors = 0;
-        let warnings = 0;
-        let cached = 0;
-        let t = Date.now();
-        lintSpinner.start();
-        for (let i = 0; i < parsed.fileNames.length; i++) {
-            const fileName = parsed.fileNames[i];
-            if (Date.now() - t > 100) {
-                t = Date.now();
-                lintSpinner.message(`${gray}[${i + 1}/${parsed.fileNames.length}] ${path.relative(process.cwd(), fileName)}${reset}`);
+        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;
@@ -149,40 +197,17 @@ const reset = '\x1b[0m';
                 }
             }
             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;
-                    }
-                    const 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;
-                }
+                diagnostics = await linterWorker.lintAndFix(fileName, fileCache);
             }
             else {
-                const diagnostics = linter.lint(fileName, fileCache);
+                diagnostics = await linterWorker.lint(fileName, fileCache);
+            }
+            if (diagnostics.length) {
+                hasFix ||= await linterWorker.hasCodeFixes(fileName);
                 for (const diagnostic of diagnostics) {
                     if (diagnostic.category === ts.DiagnosticCategory.Suggestion) {
                         continue;
@@ -192,77 +217,84 @@ const reset = '\x1b[0m';
                         getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? x => x : x => x.toLowerCase(),
                         getNewLine: () => ts.sys.newLine,
                     });
-                    output = output.replace(`TS${diagnostic.code}`, `TSSLint(${diagnostic.code})`);
+                    output = output.replace(`TS${diagnostic.code}`, String(diagnostic.code));
                     if (diagnostic.category === ts.DiagnosticCategory.Error) {
                         errors++;
-                        clack.log.error(output);
+                        log(output, 1);
                     }
                     else if (diagnostic.category === ts.DiagnosticCategory.Warning) {
                         warnings++;
-                        clack.log.warn(output);
+                        log(output, 2);
                     }
                     else {
-                        clack.log.info(output);
+                        log(output);
                     }
                 }
-                if (diagnostics.length) {
-                    hasFix ||= linter.hasCodeFixes(fileName);
-                    hasError ||= diagnostics.some(diagnostic => diagnostic.category === ts.DiagnosticCategory.Error);
-                }
-                else {
-                    passed++;
-                }
             }
+            else if (!(await linterWorker.hasRules(fileName, fileCache[4]))) {
+                excluded++;
+            }
+            else {
+                passed++;
+            }
+            processed++;
+            removeProcessFile(fileName);
         }
-        if (cached) {
-            lintSpinner.stop(`${gray}Checked ${parsed.fileNames.length} files with cache.${reset} ${gray}(Use --force to ignore cache.)${reset}`);
-        }
-        else {
-            lintSpinner.stop(`${gray}Checked ${parsed.fileNames.length} files.${reset}`);
-        }
-        if (hasFix) {
-            clack.log.message(`${gray}Use --fix to apply fixes.${reset}`);
+        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)));
         }
-        const data = [
-            [passed, 'passed', green],
-            [errors, 'errors', red],
-            [warnings, 'warnings', yellow],
-        ];
-        const summary = data
-            .filter(([count]) => count)
-            .map(([count, label, color]) => `${color}${count} ${label}${reset}`)
-            .join(` ${gray}|${reset} `);
-        clack.outro(summary);
-        cache.saveCache(configFile, lintCache, ts.sys.createHash);
+        return await builtConfigs.get(configFile);
     }
-    async function getTsconfigPath(tsconfig) {
-        if (!tsconfig) {
-            tsconfig = ts.findConfigFile(process.cwd(), ts.sys.fileExists);
-            let shortTsconfig = tsconfig ? path.relative(process.cwd(), tsconfig) : undefined;
-            if (!shortTsconfig?.startsWith('.')) {
-                shortTsconfig = `./${shortTsconfig}`;
-            }
-            tsconfig = await clack.text({
-                message: 'Select the tsconfig project. (Use --project or --projects to skip this prompt.)',
-                placeholder: shortTsconfig ? `${shortTsconfig} (${parseCommonLine(tsconfig).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 `File not found!`;
-                    }
-                },
-            });
+    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}`;
         }
-        tsconfig = require.resolve(tsconfig, { paths: [process.cwd()] });
-        return tsconfig;
+        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();
+    }
+    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`);
+        }
+    }
+    function log(msg, code) {
+        spinner.stop(msg, code);
+        spinner = clack.spinner();
+        spinner.start();
+    }
 })();
 //# 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/worker.d.ts

@@ -0,0 +1,22 @@
+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>;
+    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>;
+};
+export declare function create(): {
+    setup(tsconfig: 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 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,220 @@
+"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");
+let projectVersion = 0;
+let typeRootsVersion = 0;
+let options = {};
+let fileNames = [];
+let linter;
+const snapshots = new Map();
+const versions = new Map();
+const languageServiceHost = {
+    ...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 languageService = ts.createLanguageService(languageServiceHost);
+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);
+        },
+        async 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, 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;
+    }
+    projectVersion++;
+    typeRootsVersion++;
+    fileNames = _fileNames;
+    options = _options;
+    linter = core.createLinter({
+        configFile,
+        languageService,
+        languageServiceHost,
+        typescript: ts,
+        tsconfig: ts.server.toNormalizedPath(tsconfig),
+    }, config, 'cli', clack);
+    return true;
+}
+function lintAndFix(fileName, fileCache) {
+    let retry = 3;
+    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);
+        const fixes = linter
+            .getCodeFixes(fileName, 0, Number.MAX_VALUE, diagnostics, fileCache[4])
+            .filter(fix => fix.fixId === 'tsslint');
+        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);
+    }
+    return [
+        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,
+            })),
+        })),
+        fileCache,
+    ];
+}
+function lint(fileName, fileCache) {
+    return [
+        linter.lint(fileName, fileCache).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,
+            })),
+        })),
+        fileCache,
+    ];
+}
+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.5",
+	"version": "1.4.0",
 	"license": "MIT",
 	"bin": {
 		"tsslint": "./bin/tsslint.js"
@@ -16,12 +16,12 @@
 	},
 	"dependencies": {
 		"@clack/prompts": "^0.8.2",
-		"@tsslint/config": "1.3.5",
-		"@tsslint/core": "1.3.5",
+		"@tsslint/config": "1.4.0",
+		"@tsslint/core": "1.4.0",
 		"glob": "^10.4.1"
 	},
 	"peerDependencies": {
 		"typescript": "*"
 	},
-	"gitHead": "6fd4e516735cdf1205a3fa0df91933de72f62476"
+	"gitHead": "9a3f7ce55f079eaaedfb61af9b72d8ba736f0123"
 }