@tsslint/cli 1.5.0 → 1.5.2

package/index.js

@@ -169,10 +169,6 @@ 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 = [
             {
                 projectFlags: ['--project', '--projects'],
@@ -260,6 +256,14 @@ class Project {
             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 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.`));
+    }
     const data = [
         [passed, 'passed', lightGreen],
         [errors, 'errors', lightRed],
@@ -303,7 +307,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();
@@ -311,8 +318,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] = {};
                 }
@@ -321,7 +328,7 @@ class Project {
                 }
             }
             else {
-                project.cache[fileName] = fileCache = [fileMtime, {}, {}, false];
+                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);

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/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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/cli",
-	"version": "1.5.0",
+	"version": "1.5.2",
 	"license": "MIT",
 	"bin": {
 		"tsslint": "./bin/tsslint.js"
@@ -16,8 +16,8 @@
 	},
 	"dependencies": {
 		"@clack/prompts": "^0.8.2",
-		"@tsslint/config": "1.5.0",
-		"@tsslint/core": "1.5.0",
+		"@tsslint/config": "1.5.2",
+		"@tsslint/core": "1.5.2",
 		"@volar/language-core": "~2.4.0",
 		"@volar/typescript": "~2.4.0",
 		"glob": "^10.4.1",
@@ -29,5 +29,5 @@
 	"devDependencies": {
 		"@vue/language-core": "latest"
 	},
-	"gitHead": "6585740b4ecbc8251163923b4e8c7978fe9cb12c"
+	"gitHead": "7d5ed919f5a6ac75b76319396ff2d43b5d9a8ad4"
 }