@tsslint/cli 1.4.6 → 1.5.1

package/index.js

@@ -9,8 +9,10 @@ const glob = require("glob");
 const fs = require("fs");
 const os = require("os");
 const languagePlugins = require("./lib/languagePlugins.js");
+const formatting_js_1 = require("./lib/formatting.js");
 const _reset = '\x1b[0m';
 const purple = (s) => '\x1b[35m' + s + _reset;
+const cyan = (s) => '\x1b[36m' + s + _reset;
 const darkGray = (s) => '\x1b[90m' + s + _reset;
 const lightRed = (s) => '\x1b[91m' + s + _reset;
 const lightGreen = (s) => '\x1b[92m' + s + _reset;
@@ -31,20 +33,14 @@ if (process.argv.includes('--threads')) {
     threads = Math.min(os.availableParallelism(), Number(threadsArg));
 }
 class Project {
-    constructor(tsconfigOption, languages) {
+    constructor(tsconfig, languages) {
+        this.tsconfig = tsconfig;
         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
@@ -88,6 +84,8 @@ class Project {
     const builtConfigs = new Map();
     const clack = await import('@clack/prompts');
     const processFiles = new Set();
+    const tsconfigAndLanguages = new Map();
+    const formattingSettings = getFormattingSettings();
     let projects = [];
     let spinner = clack.spinner();
     let lastSpinnerUpdate = Date.now();
@@ -99,15 +97,16 @@ class Project {
     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')) {
+    if (![
+        '--project',
+        '--projects',
+        '--vue-project',
+        '--vue-projects',
+        '--mdx-project',
+        '--mdx-projects',
+        '--astro-project',
+        '--astro-projects',
+    ].some(flag => process.argv.includes(flag))) {
         const languages = await clack.multiselect({
             required: false,
             message: 'Select frameworks (optional)',
@@ -154,21 +153,11 @@ class Project {
         }
         let command = 'tsslint';
         if (!languages.length) {
-            if (selectedTsconfigs.length === 1) {
-                command += ' --project ' + selectedTsconfigs[0];
-            }
-            else {
-                command += ' --projects ' + selectedTsconfigs.join(' ');
-            }
+            command += ' --project ' + selectedTsconfigs.join(' ');
         }
         else {
             for (const language of languages) {
-                if (selectedTsconfigs.length === 1) {
-                    command += ` --${language}-project ` + selectedTsconfigs[0];
-                }
-                else {
-                    command += ` --${language}-projects ` + selectedTsconfigs.join(' ');
-                }
+                command += ` --${language}-project ` + selectedTsconfigs.join(' ');
             }
         }
         clack.log.info(`Running: ${purple(command)}`);
@@ -182,75 +171,55 @@ class Project {
     else {
         const options = [
             {
-                projectFlag: '--project',
-                projectsFlag: '--projects',
+                projectFlags: ['--project', '--projects'],
                 language: undefined,
             },
             {
-                projectFlag: '--vue-project',
-                projectsFlag: '--vue-projects',
+                projectFlags: ['--vue-project', '--vue-projects'],
                 language: 'vue',
             },
             {
-                projectFlag: '--mdx-project',
+                projectFlags: ['--mdx-project', '--mdx-projects'],
                 projectsFlag: '--mdx-projects',
                 language: 'mdx',
             },
             {
-                projectFlag: '--astro-project',
-                projectsFlag: '--astro-projects',
+                projectFlags: ['--astro-project', '--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, []);
+        for (const { projectFlags, language } of options) {
+            const projectFlag = projectFlags.find(flag => process.argv.includes(flag));
+            if (!projectFlag) {
+                continue;
+            }
+            let foundArg = false;
+            const projectsIndex = process.argv.indexOf(projectFlag);
+            for (let i = projectsIndex + 1; i < process.argv.length; i++) {
+                if (process.argv[i].startsWith('-')) {
+                    break;
                 }
-                if (language) {
-                    tsconfigAndLanguages.get(tsconfig).push(language);
+                foundArg = true;
+                const searchGlob = process.argv[i];
+                const tsconfigs = glob.sync(searchGlob);
+                if (!tsconfigs.length) {
+                    clack.log.error(lightRed(`No projects found for ${projectFlag} ${searchGlob}.`));
+                    process.exit(1);
                 }
-            }
-            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;
+                for (let tsconfig of tsconfigs) {
+                    tsconfig = resolvePath(tsconfig);
+                    if (!tsconfigAndLanguages.has(tsconfig)) {
+                        tsconfigAndLanguages.set(tsconfig, []);
                     }
-                    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);
+                    if (language) {
+                        tsconfigAndLanguages.get(tsconfig).push(language);
                     }
-                    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);
                 }
             }
+            if (!foundArg) {
+                clack.log.error(lightRed(`Missing argument for ${projectFlag}.`));
+                process.exit(1);
+            }
         }
     }
     for (const [tsconfig, languages] of tsconfigAndLanguages) {
@@ -270,17 +239,26 @@ class Project {
         spinner.stop(lightYellow('No input files.'));
         process.exit(1);
     }
-    if (threads === 1) {
-        await startWorker(worker.createLocal());
+    await Promise.all(new Array(threads).fill(0).map(() => {
+        return startWorker(worker.create());
+    }));
+    spinner.stop(cached
+        ? darkGray(`Processed ${processed} files with cache. (Use `) + cyan(`--force`) + darkGray(` to ignore cache.)`)
+        : darkGray(`Processed ${processed} files.`));
+    if (process.argv.includes('--fix') && !formattingSettings) {
+        const vscodeSettings = ts.findConfigFile(process.cwd(), ts.sys.fileExists, '.vscode/settings.json');
+        if (vscodeSettings) {
+            clack.log.message(darkGray(`Found available editor settings, you can use `) + cyan(`--vscode-settings ${path.relative(process.cwd(), vscodeSettings)}`) + darkGray(` to enable code format.`));
+        }
     }
-    else {
-        await Promise.all(new Array(threads).fill(0).map(() => {
-            return startWorker(worker.create());
-        }));
+    const projectsFlag = process.argv.find(arg => arg.endsWith('-projects'));
+    if (projectsFlag) {
+        clack.log.warn(darkGray(`Please use `)
+            + cyan(`${projectsFlag.slice(0, -1)}`)
+            + darkGray(` instead of `)
+            + cyan(`${projectsFlag}`)
+            + darkGray(` starting from version 1.5.0.`));
     }
-    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],
@@ -292,7 +270,7 @@ class Project {
         .map(([count, label, color]) => color(`${count} ${label}`))
         .join(darkGray(' | '));
     if (hasFix) {
-        summary += darkGray(` (Use --fix to apply automatic fixes.)`);
+        summary += darkGray(` (Use `) + cyan(`--fix`) + darkGray(` to apply automatic fixes.)`);
     }
     else if (errors || warnings) {
         summary += darkGray(` (No fixes available.)`);
@@ -315,7 +293,7 @@ class Project {
             })[0];
         }
         project.workers.push(linterWorker);
-        const setupSuccess = await linterWorker.setup(project.tsconfig, project.languages, 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, formattingSettings);
         if (!setupSuccess) {
             projects = projects.filter(p => p !== project);
             startWorker(linterWorker);
@@ -324,7 +302,10 @@ class Project {
         while (project.currentFileIndex < project.fileNames.length) {
             const i = project.currentFileIndex++;
             const fileName = project.fileNames[i];
-            const fileMtime = fs.statSync(fileName).mtimeMs;
+            const fileStat = fs.statSync(fileName, { throwIfNoEntry: false });
+            if (!fileStat) {
+                continue;
+            }
             addProcessFile(fileName);
             if (Date.now() - lastSpinnerUpdate > 100) {
                 lastSpinnerUpdate = Date.now();
@@ -332,8 +313,8 @@ class Project {
             }
             let fileCache = project.cache[fileName];
             if (fileCache) {
-                if (fileCache[0] !== fileMtime) {
-                    fileCache[0] = fileMtime;
+                if (fileCache[0] !== fileStat.mtimeMs) {
+                    fileCache[0] = fileStat.mtimeMs;
                     fileCache[1] = {};
                     fileCache[2] = {};
                 }
@@ -342,15 +323,9 @@ class Project {
                 }
             }
             else {
-                project.cache[fileName] = fileCache = [fileMtime, {}, {}];
-            }
-            let diagnostics;
-            if (process.argv.includes('--fix')) {
-                diagnostics = await linterWorker.lintAndFix(fileName, fileCache);
-            }
-            else {
-                diagnostics = await linterWorker.lint(fileName, fileCache);
+                project.cache[fileName] = fileCache = [fileStat.mtimeMs, {}, {}, false];
             }
+            let diagnostics = await linterWorker.lint(fileName, process.argv.includes('--fix'), fileCache);
             diagnostics = diagnostics.filter(diagnostic => diagnostic.category !== ts.DiagnosticCategory.Suggestion);
             if (diagnostics.length) {
                 hasFix ||= await linterWorker.hasCodeFixes(fileName);
@@ -388,6 +363,60 @@ class Project {
         cache.saveCache(project.tsconfig, project.configFile, project.cache, ts.sys.createHash);
         await startWorker(linterWorker);
     }
+    function getFormattingSettings() {
+        let formattingSettings;
+        if (process.argv.includes('--vscode-settings')) {
+            formattingSettings = {
+                typescript: {},
+                javascript: {},
+                vue: {},
+            };
+            for (const section of ['typescript', 'javascript']) {
+                formattingSettings[section] = {
+                    ...ts.getDefaultFormatCodeSettings('\n'),
+                    indentStyle: ts.IndentStyle.Smart,
+                    newLineCharacter: '\n',
+                    insertSpaceAfterCommaDelimiter: true,
+                    insertSpaceAfterConstructor: false,
+                    insertSpaceAfterSemicolonInForStatements: true,
+                    insertSpaceBeforeAndAfterBinaryOperators: true,
+                    insertSpaceAfterKeywordsInControlFlowStatements: true,
+                    insertSpaceAfterFunctionKeywordForAnonymousFunctions: true,
+                    insertSpaceBeforeFunctionParenthesis: false,
+                    insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
+                    insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
+                    insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+                    insertSpaceAfterOpeningAndBeforeClosingEmptyBraces: true,
+                    insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
+                    insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
+                    insertSpaceAfterTypeAssertion: false,
+                    placeOpenBraceOnNewLineForFunctions: false,
+                    placeOpenBraceOnNewLineForControlBlocks: false,
+                    semicolons: ts.SemicolonPreference.Ignore,
+                };
+            }
+            let vscodeSettingsConfig = process.argv[process.argv.indexOf('--vscode-settings') + 1];
+            if (!vscodeSettingsConfig || vscodeSettingsConfig.startsWith('-')) {
+                clack.log.error(lightRed(`Missing argument for --vscode-settings.`));
+                process.exit(1);
+            }
+            const vscodeSettingsFile = resolvePath(vscodeSettingsConfig);
+            const vscodeSettings = (0, formatting_js_1.getVSCodeFormattingSettings)(vscodeSettingsFile);
+            formattingSettings.typescript = {
+                ...formattingSettings.typescript,
+                ...vscodeSettings.typescript,
+            };
+            formattingSettings.javascript = {
+                ...formattingSettings.javascript,
+                ...vscodeSettings.javascript,
+            };
+            formattingSettings.vue = {
+                ...formattingSettings.vue,
+                ...vscodeSettings.vue,
+            };
+        }
+        return formattingSettings;
+    }
     async function getBuiltConfig(configFile) {
         if (!builtConfigs.has(configFile)) {
             builtConfigs.set(configFile, core.buildConfig(configFile, ts.sys.createHash, spinner, (s, code) => log(darkGray(s), code)));
@@ -416,6 +445,20 @@ class Project {
         spinner = clack.spinner();
         spinner.start();
     }
+    function resolvePath(p) {
+        if (!path.isAbsolute(p)
+            && !p.startsWith('./')
+            && !p.startsWith('../')) {
+            p = `./${p}`;
+        }
+        try {
+            return require.resolve(p, { paths: [process.cwd()] });
+        }
+        catch {
+            clack.log.error(lightRed(`No such file: ${p}`));
+            process.exit(1);
+        }
+    }
 })();
 async function parseCommonLine(tsconfig, languages) {
     const jsonConfigFile = ts.readJsonConfigFile(tsconfig, ts.sys.readFile);

package/lib/cli-options.d.ts

@@ -0,0 +1,9 @@
+export interface CliOptions {
+	threads: number;
+	force: boolean;
+	fix: boolean;
+	vscodeSettings?: string;
+	projects: Map<string, string[]>;
+}
+export declare function parseProjectOptions(argv: string[], options: CliOptions): void;
+export declare function parseCliOptions(argv: string[]): CliOptions;

package/lib/cli-options.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProjectOptions = parseProjectOptions;
+exports.parseCliOptions = parseCliOptions;
+const os = require("os");
+function parseProjectOptions(argv, options) {
+    const projectFlags = [
+        { flags: ['--project', '--projects'], language: undefined },
+        { flags: ['--vue-project', '--vue-projects'], language: 'vue' },
+        { flags: ['--mdx-project', '--mdx-projects'], language: 'mdx' },
+        { flags: ['--astro-project', '--astro-projects'], language: 'astro' }
+    ];
+    for (const { flags, language } of projectFlags) {
+        const flag = flags.find(f => argv.includes(f));
+        if (!flag)
+            continue;
+        const flagIndex = argv.indexOf(flag);
+        for (let i = flagIndex + 1; i < argv.length && !argv[i].startsWith('-'); i++) {
+            const tsconfig = argv[i];
+            if (!options.projects.has(tsconfig)) {
+                options.projects.set(tsconfig, []);
+            }
+            if (language) {
+                options.projects.get(tsconfig).push(language);
+            }
+        }
+    }
+}
+function parseCliOptions(argv) {
+    const options = {
+        threads: 1,
+        force: argv.includes('--force'),
+        fix: argv.includes('--fix'),
+        projects: new Map()
+    };
+    if (argv.includes('--threads')) {
+        const threadsIndex = argv.indexOf('--threads');
+        const threadsArg = argv[threadsIndex + 1];
+        if (!threadsArg || threadsArg.startsWith('-')) {
+            throw new Error('Missing argument for --threads');
+        }
+        options.threads = Math.min(os.availableParallelism(), Number(threadsArg));
+    }
+    if (argv.includes('--vscode-settings')) {
+        const settingsIndex = argv.indexOf('--vscode-settings');
+        const settingsPath = argv[settingsIndex + 1];
+        if (!settingsPath || settingsPath.startsWith('-')) {
+            throw new Error('Missing argument for --vscode-settings');
+        }
+        options.vscodeSettings = settingsPath;
+    }
+    parseProjectOptions(argv, options);
+    return options;
+}
+//# sourceMappingURL=cli-options.js.map

package/lib/formatting.d.ts

@@ -0,0 +1,9 @@
+import type * as ts from 'typescript';
+export declare function getVSCodeFormattingSettings(settingsFile: string): {
+    javascript: ts.FormatCodeSettings;
+    typescript: ts.FormatCodeSettings;
+    vue: {
+        'script.initialIndent'?: boolean;
+    };
+};
+export declare function computeInitialIndent(content: string, i: number, baseTabSize?: number): number;

package/lib/formatting.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVSCodeFormattingSettings = getVSCodeFormattingSettings;
+exports.computeInitialIndent = computeInitialIndent;
+const fs = require("fs");
+const json5 = require("json5");
+function getVSCodeFormattingSettings(settingsFile) {
+    const jsonc = fs.readFileSync(settingsFile, 'utf8');
+    const editorSettings = json5.parse(jsonc);
+    const jsSettings = {};
+    const tsSettings = {};
+    const vueSettings = {};
+    if ('editor.insertSpaces' in editorSettings) {
+        jsSettings.convertTabsToSpaces = !!editorSettings['editor.insertSpaces'];
+        tsSettings.convertTabsToSpaces = !!editorSettings['editor.insertSpaces'];
+    }
+    if ('editor.tabSize' in editorSettings) {
+        jsSettings.tabSize = editorSettings['editor.tabSize'];
+        tsSettings.tabSize = editorSettings['editor.tabSize'];
+    }
+    for (const key in editorSettings) {
+        if (key.startsWith('javascript.format.')) {
+            const settingKey = key.slice('javascript.format.'.length);
+            // @ts-expect-error
+            jsSettings[settingKey] = editorSettings[key];
+        }
+        else if (key.startsWith('typescript.format.')) {
+            const settingKey = key.slice('typescript.format.'.length);
+            // @ts-expect-error
+            tsSettings[settingKey] = editorSettings[key];
+        }
+    }
+    if ('vue.format.script.initialIndent' in editorSettings) {
+        vueSettings['script.initialIndent'] = !!editorSettings['vue.format.script.initialIndent'];
+    }
+    return {
+        javascript: jsSettings,
+        typescript: tsSettings,
+        vue: vueSettings,
+    };
+}
+function computeInitialIndent(content, i, baseTabSize) {
+    let nChars = 0;
+    const tabSize = baseTabSize || 4;
+    while (i < content.length) {
+        const ch = content.charAt(i);
+        if (ch === ' ') {
+            nChars++;
+        }
+        else if (ch === '\t') {
+            nChars += tabSize;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    return Math.floor(nChars / tabSize);
+}
+//# sourceMappingURL=formatting.js.map

package/lib/logger.d.ts

@@ -0,0 +1,25 @@
+export interface SpinnerHandle {
+	start(text?: string): void;
+	stop(text?: string): void;
+}
+export declare const purple: (s: string) => string;
+export declare const cyan: (s: string) => string;
+export declare const darkGray: (s: string) => string;
+export declare const lightRed: (s: string) => string;
+export declare const lightGreen: (s: string) => string;
+export declare const lightYellow: (s: string) => string;
+export declare const colors: {
+	ts: (s: string) => string;
+	vue: (s: string) => string;
+	mdx: (s: string) => string;
+	astro: (s: string) => string;
+};
+export declare class Logger {
+	private createSpinner;
+	private spinnerHandle?;
+	constructor(createSpinner: () => SpinnerHandle);
+	startSpinner(message: string): void;
+	error(msg: string): void;
+	warn(msg: string): void;
+	info(msg: string): void;
+}

package/lib/logger.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.colors = exports.lightYellow = exports.lightGreen = exports.lightRed = exports.darkGray = exports.cyan = exports.purple = void 0;
+const _reset = '\x1b[0m';
+const purple = (s) => '\x1b[35m' + s + _reset;
+exports.purple = purple;
+const cyan = (s) => '\x1b[36m' + s + _reset;
+exports.cyan = cyan;
+const darkGray = (s) => '\x1b[90m' + s + _reset;
+exports.darkGray = darkGray;
+const lightRed = (s) => '\x1b[91m' + s + _reset;
+exports.lightRed = lightRed;
+const lightGreen = (s) => '\x1b[92m' + s + _reset;
+exports.lightGreen = lightGreen;
+const lightYellow = (s) => '\x1b[93m' + s + _reset;
+exports.lightYellow = lightYellow;
+exports.colors = {
+    ts: (s) => '\x1b[34m' + s + _reset,
+    vue: (s) => '\x1b[32m' + s + _reset,
+    mdx: (s) => '\x1b[33m' + s + _reset,
+    astro: (s) => '\x1b[38;5;209m' + s + _reset
+};
+class Logger {
+    constructor(createSpinner) {
+        this.createSpinner = createSpinner;
+    }
+    startSpinner(message) {
+        this.spinnerHandle = this.createSpinner();
+        this.spinnerHandle.start(message);
+    }
+    error(msg) {
+        this.spinnerHandle?.stop((0, exports.lightRed)(msg));
+    }
+    warn(msg) {
+        this.spinnerHandle?.stop((0, exports.lightYellow)(msg));
+    }
+    info(msg) {
+        this.spinnerHandle?.stop(msg);
+    }
+}
+exports.Logger = Logger;
+//# sourceMappingURL=logger.js.map

package/lib/project.d.ts

@@ -0,0 +1,17 @@
+import ts = require('typescript');
+import cache = require('./cache.js');
+import worker = require('./worker.js');
+export declare class Project {
+	tsconfig: string;
+	languages: string[];
+	workers: ReturnType<typeof worker.create>[];
+	fileNames: string[];
+	options: ts.CompilerOptions;
+	configFile: string | undefined;
+	currentFileIndex: number;
+	builtConfig: string | undefined;
+	cache: cache.CacheData;
+	constructor(tsconfig: string, languages: string[]);
+	init(clack: typeof import('@clack/prompts')): Promise<this>;
+	private getProjectLabels;
+}

package/lib/project.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Project = void 0;
+const ts = require("typescript");
+const path = require("path");
+const core = require("@tsslint/core");
+const cache = require("./cache.js");
+const languagePlugins = require("./languagePlugins.js");
+const logger_js_1 = require("./logger.js");
+class Project {
+    constructor(tsconfig, languages) {
+        this.tsconfig = tsconfig;
+        this.languages = languages;
+        this.workers = [];
+        this.fileNames = [];
+        this.options = {};
+        this.currentFileIndex = 0;
+        this.cache = {};
+    }
+    async init(clack) {
+        this.configFile = ts.findConfigFile(path.dirname(this.tsconfig), ts.sys.fileExists, 'tsslint.config.ts');
+        const labels = this.getProjectLabels();
+        const label = labels.join((0, logger_js_1.darkGray)(' | '));
+        if (!this.configFile) {
+            clack.log.error(`${label} ${path.relative(process.cwd(), this.tsconfig)} ${(0, logger_js_1.darkGray)('(No tsslint.config.ts found)')}`);
+            return this;
+        }
+        const spinner = clack.spinner();
+        try {
+            this.builtConfig = await core.buildConfig(this.configFile, ts.sys.createHash, spinner, (s, code) => clack.log.error((0, logger_js_1.darkGray)(s)));
+        }
+        catch (err) {
+            spinner.stop();
+            if (err instanceof Error) {
+                clack.log.error(err.stack ?? err.message);
+            }
+            else {
+                clack.log.error(String(err));
+            }
+            return this;
+        }
+        if (!this.builtConfig) {
+            spinner.stop();
+            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(`${label} ${path.relative(process.cwd(), this.tsconfig)} ${(0, logger_js_1.darkGray)('(No included files)')}`);
+            return this;
+        }
+        clack.log.info(`${label} ${path.relative(process.cwd(), this.tsconfig)} ${(0, logger_js_1.darkGray)(`(${this.fileNames.length})`)}`);
+        if (!process.argv.includes('--force')) {
+            this.cache = cache.loadCache(this.tsconfig, this.configFile, ts.sys.createHash);
+        }
+        return this;
+    }
+    getProjectLabels() {
+        if (this.languages.length === 0) {
+            return [logger_js_1.colors.ts('TS')];
+        }
+        const labels = [];
+        if (this.languages.includes('vue')) {
+            labels.push(logger_js_1.colors.vue('Vue'));
+        }
+        if (this.languages.includes('mdx')) {
+            labels.push(logger_js_1.colors.mdx('MDX'));
+        }
+        if (this.languages.includes('astro')) {
+            labels.push(logger_js_1.colors.astro('Astro'));
+        }
+        return labels;
+    }
+}
+exports.Project = Project;
+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=project.js.map

package/lib/runner.d.ts

@@ -0,0 +1,31 @@
+import type { Project } from './project';
+import type { CliOptions } from './cli-options';
+import type { Logger } from './logger';
+export interface RunnerStats {
+	processed: number;
+	excluded: number;
+	passed: number;
+	errors: number;
+	warnings: number;
+	cached: number;
+	hasFix: boolean;
+}
+export declare class Runner {
+	private projects;
+	private options;
+	private logger;
+	private stats;
+	private processFiles;
+	private lastSpinnerUpdate;
+	private readonly allFilesNum;
+	constructor(projects: Project[], options: CliOptions, logger: Logger);
+	run(): Promise<RunnerStats>;
+	private startWorker;
+	private selectProject;
+	private processProject;
+	private processFile;
+	private addProcessFile;
+	private removeProcessFile;
+	private updateSpinner;
+	private updateStats;
+}

package/lib/runner.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runner = void 0;
+const worker = require("./worker");
+const cache = require("./cache");
+const ts = require("typescript");
+const path = require("path");
+const formatting_1 = require("./formatting");
+const logger_1 = require("./logger");
+class Runner {
+    constructor(projects, options, logger) {
+        this.projects = projects;
+        this.options = options;
+        this.logger = logger;
+        this.stats = {
+            processed: 0,
+            excluded: 0,
+            passed: 0,
+            errors: 0,
+            warnings: 0,
+            cached: 0,
+            hasFix: false
+        };
+        this.processFiles = new Set();
+        this.lastSpinnerUpdate = Date.now();
+        this.allFilesNum = projects.reduce((sum, p) => sum + p.fileNames.length, 0);
+    }
+    async run() {
+        if (this.allFilesNum === 0) {
+            this.logger.warn('No input files.');
+            process.exit(1);
+        }
+        if (this.options.threads === 1) {
+            await this.startWorker(worker.createLocal());
+        }
+        else {
+            await Promise.all(new Array(this.options.threads)
+                .fill(0)
+                .map(() => this.startWorker(worker.create())));
+        }
+        return this.stats;
+    }
+    async startWorker(linterWorker) {
+        const unfinishedProjects = this.projects.filter(project => project.currentFileIndex < project.fileNames.length);
+        if (!unfinishedProjects.length)
+            return;
+        const project = this.selectProject(unfinishedProjects);
+        project.workers.push(linterWorker);
+        const formattingSettings = this.options.vscodeSettings
+            ? (0, formatting_1.getVSCodeFormattingSettings)(this.options.vscodeSettings)
+            : undefined;
+        const setupSuccess = await linterWorker.setup(project.tsconfig, project.languages, project.configFile, project.builtConfig, project.fileNames, project.options, formattingSettings);
+        if (!setupSuccess) {
+            this.projects = this.projects.filter(p => p !== project);
+            await this.startWorker(linterWorker);
+            return;
+        }
+        await this.processProject(project, linterWorker);
+        await this.startWorker(linterWorker);
+    }
+    selectProject(unfinishedProjects) {
+        // First try to find a project without workers
+        const projectWithoutWorker = unfinishedProjects.find(p => !p.workers.length);
+        if (projectWithoutWorker) {
+            return projectWithoutWorker;
+        }
+        // Otherwise choose project with most files left per worker
+        return unfinishedProjects.sort((a, b) => {
+            const aFilesPerWorker = (a.fileNames.length - a.currentFileIndex) / (a.workers.length || 1);
+            const bFilesPerWorker = (b.fileNames.length - b.currentFileIndex) / (b.workers.length || 1);
+            return bFilesPerWorker - aFilesPerWorker;
+        })[0];
+    }
+    async processProject(project, linterWorker) {
+        while (project.currentFileIndex < project.fileNames.length) {
+            await this.processFile(project, project.currentFileIndex++, linterWorker);
+        }
+        cache.saveCache(project.tsconfig, project.configFile, project.cache, ts.sys.createHash);
+    }
+    async processFile(project, fileIndex, linterWorker) {
+        const fileName = project.fileNames[fileIndex];
+        const fileStat = ts.sys.getModifiedTime(fileName);
+        this.addProcessFile(fileName);
+        if (Date.now() - this.lastSpinnerUpdate > 100) {
+            this.lastSpinnerUpdate = Date.now();
+            await new Promise(resolve => setTimeout(resolve, 0));
+            this.updateSpinner();
+        }
+        let fileCache = project.cache[fileName];
+        if (fileCache) {
+            if (fileCache[0] !== fileStat.getTime()) {
+                fileCache[0] = fileStat.getTime();
+                fileCache[1] = {};
+                fileCache[2] = {};
+            }
+            else {
+                this.stats.cached++;
+            }
+        }
+        else {
+            project.cache[fileName] = fileCache = [fileStat.getTime(), {}, {}, false];
+        }
+        const diagnostics = await linterWorker.lint(fileName, this.options.fix, fileCache);
+        if (diagnostics.length === 0) {
+            const [hasRules] = await linterWorker.hasRules(fileName, fileCache[2]);
+            if (!hasRules) {
+                this.stats.excluded++;
+                this.removeProcessFile(fileName);
+                return;
+            }
+        }
+        this.stats.hasFix ||= await linterWorker.hasCodeFixes(fileName);
+        this.updateStats(diagnostics);
+        this.removeProcessFile(fileName);
+    }
+    addProcessFile(fileName) {
+        this.processFiles.add(fileName);
+        this.updateSpinner();
+    }
+    removeProcessFile(fileName) {
+        this.processFiles.delete(fileName);
+        this.updateSpinner();
+    }
+    updateSpinner() {
+        if (this.processFiles.size === 1) {
+            const fileName = Array.from(this.processFiles)[0];
+            this.logger.startSpinner((0, logger_1.darkGray)(`[${this.stats.processed + this.processFiles.size}/${this.allFilesNum}] ${path.relative(process.cwd(), fileName)}`));
+        }
+        else {
+            this.logger.startSpinner((0, logger_1.darkGray)(`[${this.stats.processed + this.processFiles.size}/${this.allFilesNum}] Processing ${this.processFiles.size} files`));
+        }
+    }
+    updateStats(diagnostics) {
+        if (diagnostics.length === 0) {
+            this.stats.passed++;
+        }
+        else {
+            for (const diagnostic of diagnostics) {
+                if (diagnostic.category === ts.DiagnosticCategory.Error) {
+                    this.stats.errors++;
+                }
+                else if (diagnostic.category === ts.DiagnosticCategory.Warning) {
+                    this.stats.warnings++;
+                }
+            }
+        }
+        this.stats.processed++;
+    }
+}
+exports.Runner = Runner;
+//# sourceMappingURL=runner.js.map

package/lib/worker.d.ts

@@ -1,22 +1,32 @@
 import ts = require('typescript');
 import core = require('@tsslint/core');
+import { type getVSCodeFormattingSettings } from './formatting.js';
 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[];
+    setup(tsconfig: string, languages: string[], configFile: string, builtConfig: string, _fileNames: string[], _options: ts.CompilerOptions, _fmtSettings: {
+        javascript: ts.FormatCodeSettings;
+        typescript: ts.FormatCodeSettings;
+        vue: {
+            'script.initialIndent'?: boolean;
+        };
+    } | undefined): Promise<boolean>;
+    lint(fileName: string, fix: boolean, 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[]>;
+    setup(tsconfig: string, languages: string[], configFile: string, builtConfig: string, _fileNames: string[], _options: ts.CompilerOptions, _fmtSettings: {
+        javascript: ts.FormatCodeSettings;
+        typescript: ts.FormatCodeSettings;
+        vue: {
+            'script.initialIndent'?: boolean;
+        };
+    } | undefined): Promise<boolean>;
+    lint(fileName: string, fix: boolean, 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 setup(tsconfig: string, languages: string[], configFile: string, builtConfig: string, _fileNames: string[], _options: ts.CompilerOptions, _fmtSettings: ReturnType<typeof getVSCodeFormattingSettings> | undefined): Promise<boolean>;
+declare function lint(fileName: string, fix: boolean, fileCache: core.FileLintCache): readonly [ts.DiagnosticWithLocation[], core.FileLintCache];
 declare function hasCodeFixes(fileName: string): boolean;
 declare function hasRules(fileName: string, minimatchCache: core.FileLintCache[2]): readonly [boolean, Record<string, boolean>];
 export {};

package/lib/worker.js

@@ -6,11 +6,14 @@ const ts = require("typescript");
 const core = require("@tsslint/core");
 const url = require("url");
 const fs = require("fs");
+const path = require("path");
 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");
+const transform_js_1 = require("@volar/typescript/lib/node/transform.js");
+const formatting_js_1 = require("./formatting.js");
 let projectVersion = 0;
 let typeRootsVersion = 0;
 let options = {};
@@ -19,6 +22,42 @@ let language;
 let linter;
 let linterLanguageService;
 let linterSyntaxOnlyLanguageService;
+let fmtSettings;
+const formatLanguageService = ts.createLanguageService({
+    ...ts.sys,
+    getCompilationSettings() {
+        return options;
+    },
+    getScriptFileNames() {
+        return [];
+    },
+    getScriptVersion() {
+        return '0';
+    },
+    getScriptSnapshot() {
+        return formattingSnapshot;
+    },
+    getScriptKind() {
+        return formattingScriptKind;
+    },
+    useCaseSensitiveFileNames() {
+        return ts.sys.useCaseSensitiveFileNames;
+    },
+    getCurrentDirectory() {
+        return ts.sys.getCurrentDirectory();
+    },
+    getDefaultLibFileName() {
+        return ts.getDefaultLibFilePath(options);
+    },
+}, undefined, true);
+let formattingSnapshot;
+let formattingScriptKind;
+let formattingIndex = 0;
+function formatVirtualScript(kind, settings, snapshot) {
+    formattingSnapshot = snapshot;
+    formattingScriptKind = kind;
+    return formatLanguageService.getFormattingEditsForDocument(`${formattingIndex++}.txt`, settings);
+}
 const snapshots = new Map();
 const versions = new Map();
 const originalHost = {
@@ -78,9 +117,6 @@ function createLocal() {
         lint(...args) {
             return lint(...args)[0];
         },
-        lintAndFix(...args) {
-            return lintAndFix(...args)[0];
-        },
         hasCodeFixes(...args) {
             return hasCodeFixes(...args);
         },
@@ -100,11 +136,6 @@ function create() {
             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);
         },
@@ -131,11 +162,10 @@ worker_threads.parentPort?.on('message', async (json) => {
 const handlers = {
     setup,
     lint,
-    lintAndFix,
     hasCodeFixes,
     hasRules,
 };
-async function setup(tsconfig, languages, configFile, builtConfig, _fileNames, _options) {
+async function setup(tsconfig, languages, configFile, builtConfig, _fileNames, _options, _fmtSettings) {
     const clack = await import('@clack/prompts');
     let config;
     try {
@@ -192,27 +222,26 @@ async function setup(tsconfig, languages, configFile, builtConfig, _fileNames, _
             allowNonTsExtensions: true,
         }
         : _options;
+    fmtSettings = _fmtSettings;
     linter = core.createLinter({
-        configFile,
         languageService: linterLanguageService,
         languageServiceHost: linterHost,
         typescript: ts,
-        tsconfig: ts.server.toNormalizedPath(tsconfig),
-    }, config, 'cli', linterSyntaxOnlyLanguageService);
+    }, path.dirname(configFile), config, 'cli', linterSyntaxOnlyLanguageService);
     return true;
 }
-function lintAndFix(fileName, fileCache) {
-    let retry = 1;
-    let shouldRetry = true;
+function lint(fileName, fix, fileCache) {
     let newSnapshot;
     let diagnostics;
-    while (shouldRetry && retry--) {
+    let shouldCheck = true;
+    if (fix) {
         if (Object.values(fileCache[1]).some(([hasFix]) => hasFix)) {
             // Reset the cache if there are any fixes applied.
             fileCache[1] = {};
             fileCache[2] = {};
         }
         diagnostics = linter.lint(fileName, fileCache);
+        shouldCheck = false;
         let fixes = linter
             .getCodeFixes(fileName, 0, Number.MAX_VALUE, diagnostics, fileCache[2])
             .filter(fix => fix.fixId === 'tsslint');
@@ -224,21 +253,128 @@ function lintAndFix(fileName, fileCache) {
         }
         const textChanges = core.combineCodeFixes(fileName, fixes);
         if (textChanges.length) {
+            fileCache[3] = false;
             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 (!fileCache[3] && fmtSettings) {
+            fileCache[3] = true;
+            let script = language?.scripts.get(fileName);
+            let linterEdits = [];
+            let serviceEdits = [];
+            if (script?.generated) {
+                for (const code of (0, language_core_1.forEachEmbeddedCode)(script.generated.root)) {
+                    if ((code.languageId === 'javascript'
+                        || code.languageId === 'typescript'
+                        || code.languageId === 'javascriptreact'
+                        || code.languageId === 'typescriptreact')
+                        && code.mappings.some(mapping => (0, language_core_1.isFormattingEnabled)(mapping.data))) {
+                        const scriptKind = code.languageId === 'javascript' ? ts.ScriptKind.JS
+                            : code.languageId === 'javascriptreact' ? ts.ScriptKind.JSX
+                                : code.languageId === 'typescript' ? ts.ScriptKind.TS
+                                    : ts.ScriptKind.TSX;
+                        const sourceFile = ts.createSourceFile(fileName, code.snapshot.getText(0, code.snapshot.getLength()), ts.ScriptTarget.Latest, true, scriptKind);
+                        linterEdits.push(...linter
+                            .format(sourceFile, fileCache[2])
+                            .map(edit => {
+                            return (0, transform_js_1.transformTextChange)(script, language, {
+                                code,
+                                extension: '',
+                                scriptKind: scriptKind,
+                                preventLeadingOffset: true,
+                            }, edit, false, language_core_1.isFormattingEnabled)?.[1];
+                        })
+                            .filter(edit => !!edit));
+                    }
+                }
+            }
+            else {
+                const sourceFile = originalSyntaxOnlyService.getNonBoundSourceFile(fileName);
+                linterEdits = linter.format(sourceFile, fileCache[2]);
+            }
+            if (linterEdits.length) {
+                const oldSnapshot = snapshots.get(fileName);
+                newSnapshot = core.applyTextChanges(oldSnapshot, linterEdits);
+                snapshots.set(fileName, newSnapshot);
+                versions.set(fileName, (versions.get(fileName) ?? 0) + 1);
+                projectVersion++;
+                script = language?.scripts.get(fileName);
+            }
+            if (script?.generated) {
+                let sourceFile;
+                for (const code of (0, language_core_1.forEachEmbeddedCode)(script.generated.root)) {
+                    if ((code.languageId === 'javascript'
+                        || code.languageId === 'typescript'
+                        || code.languageId === 'javascriptreact'
+                        || code.languageId === 'typescriptreact')
+                        && code.mappings.some(mapping => (0, language_core_1.isFormattingEnabled)(mapping.data))) {
+                        const scriptKind = code.languageId === 'javascript' ? ts.ScriptKind.JS
+                            : code.languageId === 'javascriptreact' ? ts.ScriptKind.JSX
+                                : code.languageId === 'typescript' ? ts.ScriptKind.TS
+                                    : ts.ScriptKind.TSX;
+                        let settings = scriptKind === ts.ScriptKind.JS || scriptKind === ts.ScriptKind.JSX
+                            ? fmtSettings.javascript
+                            : fmtSettings.typescript;
+                        if (settings.tabSize !== undefined) {
+                            const firstMapping = code.mappings[0];
+                            sourceFile ??= ts.createSourceFile(fileName, script.snapshot.getText(0, script.snapshot.getLength()), ts.ScriptTarget.Latest, true, ts.ScriptKind.Deferred);
+                            const line = sourceFile.getLineAndCharacterOfPosition(firstMapping.sourceOffsets[0]).line;
+                            const offset = sourceFile.getPositionOfLineAndCharacter(line, 0);
+                            let initialIndentLevel = (0, formatting_js_1.computeInitialIndent)(script.snapshot.getText(0, script.snapshot.getLength()), offset, settings.tabSize);
+                            if (script.languageId === 'vue'
+                                && fmtSettings.vue['script.initialIndent']
+                                && (code.id === 'script_raw'
+                                    || code.id === 'scriptsetup_raw')) {
+                                initialIndentLevel++;
+                            }
+                            settings = {
+                                ...settings,
+                                baseIndentSize: initialIndentLevel * settings.tabSize,
+                            };
+                        }
+                        serviceEdits.push(...formatVirtualScript(scriptKind, settings, code.snapshot)
+                            .map(edit => {
+                            return (0, transform_js_1.transformTextChange)(script, language, {
+                                code,
+                                extension: '',
+                                scriptKind: scriptKind,
+                                preventLeadingOffset: true,
+                            }, edit, false, language_core_1.isFormattingEnabled)?.[1];
+                        })
+                            .filter(edit => !!edit));
+                    }
+                }
+            }
+            else {
+                const scriptKind = linterHost.getScriptKind(fileName);
+                const settings = scriptKind === ts.ScriptKind.JS || scriptKind === ts.ScriptKind.JSX ? fmtSettings.javascript : fmtSettings.typescript;
+                serviceEdits = linterLanguageService.getFormattingEditsForDocument(fileName, settings);
+            }
+            if (serviceEdits.length) {
+                const oldSnapshot = snapshots.get(fileName);
+                newSnapshot = core.applyTextChanges(oldSnapshot, serviceEdits);
+                snapshots.set(fileName, newSnapshot);
+                versions.set(fileName, (versions.get(fileName) ?? 0) + 1);
+                projectVersion++;
+            }
         }
     }
     if (newSnapshot) {
-        ts.sys.writeFile(fileName, newSnapshot.getText(0, newSnapshot.getLength()));
-        fileCache[0] = fs.statSync(fileName).mtimeMs;
-        fileCache[1] = {};
-        fileCache[2] = {};
+        const newText = newSnapshot.getText(0, newSnapshot.getLength());
+        const oldText = ts.sys.readFile(fileName);
+        if (newText !== oldText) {
+            ts.sys.writeFile(fileName, newSnapshot.getText(0, newSnapshot.getLength()));
+            fileCache[0] = fs.statSync(fileName).mtimeMs;
+            fileCache[1] = {};
+            fileCache[2] = {};
+            fileCache[3] = false;
+            shouldCheck = true;
+        }
     }
-    if (shouldRetry) {
+    if (shouldCheck) {
         diagnostics = linter.lint(fileName, fileCache);
     }
     if (language) {
@@ -278,45 +414,6 @@ function lintAndFix(fileName, fileCache) {
     }
     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);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/cli",
-	"version": "1.4.6",
+	"version": "1.5.1",
 	"license": "MIT",
 	"bin": {
 		"tsslint": "./bin/tsslint.js"
@@ -16,11 +16,12 @@
 	},
 	"dependencies": {
 		"@clack/prompts": "^0.8.2",
-		"@tsslint/config": "1.4.6",
-		"@tsslint/core": "1.4.6",
+		"@tsslint/config": "1.5.1",
+		"@tsslint/core": "1.5.1",
 		"@volar/language-core": "~2.4.0",
 		"@volar/typescript": "~2.4.0",
-		"glob": "^10.4.1"
+		"glob": "^10.4.1",
+		"json5": "^2.2.3"
 	},
 	"peerDependencies": {
 		"typescript": "*"
@@ -28,5 +29,5 @@
 	"devDependencies": {
 		"@vue/language-core": "latest"
 	},
-	"gitHead": "9c5bc3471bb1c737144f90a1a70470975088e7fc"
+	"gitHead": "a0c7b85e3ba032d5c9a92f69efbba51a9f6ce06e"
 }