@tsslint/cli 1.4.6 → 1.5.0

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)}`);
@@ -180,76 +169,60 @@ class Project {
         }
     }
     else {
+        const projectsFlag = process.argv.find(arg => arg.endsWith('-projects'));
+        if (projectsFlag) {
+            clack.log.warn(lightYellow(`Please use ${projectsFlag.slice(0, -1)} instead of ${projectsFlag} starting from version 1.5.0.`));
+        }
         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;
-                    }
-                    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) {
+                    tsconfig = resolvePath(tsconfig);
+                    if (!tsconfigAndLanguages.has(tsconfig)) {
+                        tsconfigAndLanguages.set(tsconfig, []);
                     }
-                    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 (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);
             }
         }
     }
@@ -278,9 +251,15 @@ class Project {
             return startWorker(worker.create());
         }));
     }
-    spinner.stop(darkGray(cached
-        ? `Processed ${processed} files with cache. (Use --force to ignore cache.)`
-        : `Processed ${processed} files.`));
+    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.`));
+        }
+    }
     const data = [
         [passed, 'passed', lightGreen],
         [errors, 'errors', lightRed],
@@ -292,7 +271,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 +294,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);
@@ -342,15 +321,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 = [fileMtime, {}, {}, 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 +361,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 +443,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/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/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.0",
 	"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.0",
+		"@tsslint/core": "1.5.0",
 		"@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": "6585740b4ecbc8251163923b4e8c7978fe9cb12c"
 }