xo 0.42.0 → 0.46.0

package/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import process from 'node:process';
 import getStdin from 'get-stdin';
 import meow from 'meow';
 import formatterPretty from 'eslint-formatter-pretty';
@@ -172,8 +173,8 @@ if (options.nodeVersion) {
 }
 
 (async () => {
-	if (options.printConfig) {
-		if (input.length > 0) {
+	if (typeof options.printConfig === 'string') {
+		if (input.length > 0 || options.printConfig === '') {
 			console.error('The `--print-config` flag must be used with exactly one filename');
 			process.exit(1);
 		}

package/config/plugins.cjs

@@ -3,7 +3,7 @@
 module.exports = {
 	// Repeated here from eslint-config-xo in case some plugins set something different
 	parserOptions: {
-		ecmaVersion: 2021,
+		ecmaVersion: 'latest',
 		sourceType: 'module',
 		ecmaFeatures: {
 			jsx: true,
@@ -14,7 +14,8 @@ module.exports = {
 		'no-use-extend-native',
 		'ava',
 		'unicorn',
-		'promise',
+		// Disabled as the plugin doesn't support ESLint 8 yet.
+		// 'promise',
 		'import',
 		'node',
 		'eslint-comments',
@@ -173,17 +174,19 @@ module.exports = {
 		// TODO: Temporarily disabled as the rule is buggy.
 		'function-call-argument-newline': 'off',
 
-		'promise/param-names': 'error',
-		'promise/no-return-wrap': [
-			'error',
-			{
-				allowReject: true,
-			},
-		],
-		'promise/no-new-statics': 'error',
-		'promise/no-return-in-finally': 'error',
-		'promise/valid-params': 'error',
-		'promise/prefer-await-to-then': 'error',
+		// Disabled as the plugin doesn't support ESLint 8 yet.
+		// 'promise/param-names': 'error',
+		// 'promise/no-return-wrap': [
+		// 	'error',
+		// 	{
+		// 		allowReject: true,
+		// 	},
+		// ],
+		// 'promise/no-new-statics': 'error',
+		// 'promise/no-return-in-finally': 'error',
+		// 'promise/valid-params': 'error',
+		// 'promise/prefer-await-to-then': 'error',
+
 		'import/default': 'error',
 		'import/export': 'error',
 		'import/extensions': [
@@ -200,9 +203,8 @@ module.exports = {
 		],
 		'import/first': 'error',
 
-		// Disabled as it doesn't work with TypeScript.
-		// This issue and some others: https://github.com/benmosher/eslint-plugin-import/issues/1341
-		// 'import/named': 'error',
+		// Enabled, but disabled on TypeScript (https://github.com/xojs/xo/issues/576)
+		'import/named': 'error',
 
 		'import/namespace': [
 			'error',
@@ -322,7 +324,7 @@ module.exports = {
 		'node/no-deprecated-api': 'error',
 		'node/prefer-global/buffer': [
 			'error',
-			'always',
+			'never',
 		],
 		'node/prefer-global/console': [
 			'error',
@@ -330,7 +332,7 @@ module.exports = {
 		],
 		'node/prefer-global/process': [
 			'error',
-			'always',
+			'never',
 		],
 		'node/prefer-global/text-decoder': [
 			'error',

package/index.js

@@ -1,168 +1,112 @@
 import path from 'node:path';
 import {ESLint} from 'eslint';
-import globby from 'globby';
-import {isEqual} from 'lodash-es';
+import {globby, isGitIgnoredSync} from 'globby';
+import {isEqual, groupBy} from 'lodash-es';
 import micromatch from 'micromatch';
 import arrify from 'arrify';
-import pReduce from 'p-reduce';
-import pMap from 'p-map';
-import {cosmiconfig, defaultLoaders} from 'cosmiconfig';
-import defineLazyProperty from 'define-lazy-prop';
-import pFilter from 'p-filter';
 import slash from 'slash';
-import {CONFIG_FILES, MODULE_NAME, DEFAULT_IGNORES} from './lib/constants.js';
 import {
-	normalizeOptions,
+	parseOptions,
 	getIgnores,
 	mergeWithFileConfig,
-	mergeWithFileConfigs,
-	buildConfig,
-	mergeOptions,
 } from './lib/options-manager.js';
+import {mergeReports, processReport, getIgnoredReport} from './lib/report.js';
 
-/** Merge multiple reports into a single report */
-const mergeReports = reports => {
-	const report = {
-		results: [],
-		errorCount: 0,
-		warningCount: 0,
-	};
-
-	for (const currentReport of reports) {
-		report.results.push(...currentReport.results);
-		report.errorCount += currentReport.errorCount;
-		report.warningCount += currentReport.warningCount;
-	}
-
-	return report;
-};
-
-const getReportStatistics = results => {
-	const statistics = {
-		errorCount: 0,
-		warningCount: 0,
-		fixableErrorCount: 0,
-		fixableWarningCount: 0,
-	};
-
-	for (const result of results) {
-		statistics.errorCount += result.errorCount;
-		statistics.warningCount += result.warningCount;
-		statistics.fixableErrorCount += result.fixableErrorCount;
-		statistics.fixableWarningCount += result.fixableWarningCount;
-	}
-
-	return statistics;
-};
-
-const processReport = (report, {isQuiet = false} = {}) => {
-	if (isQuiet) {
-		report = ESLint.getErrorResults(report);
-	}
-
-	const result = {
-		results: report,
-		...getReportStatistics(report),
-	};
-
-	defineLazyProperty(result, 'usedDeprecatedRules', () => {
-		const seenRules = new Set();
-		const rules = [];
-
-		for (const {usedDeprecatedRules} of report) {
-			for (const rule of usedDeprecatedRules) {
-				if (seenRules.has(rule.ruleId)) {
-					continue;
-				}
-
-				seenRules.add(rule.ruleId);
-				rules.push(rule);
-			}
-		}
+const globFiles = async (patterns, options) => {
+	const {ignores, extensions, cwd} = (await mergeWithFileConfig(options)).options;
 
-		return rules;
-	});
+	patterns = patterns.length === 0
+		? [`**/*.{${extensions.join(',')}}`]
+		: arrify(patterns).map(pattern => slash(pattern));
 
-	return result;
-};
-
-const runEslint = async (paths, options, processorOptions) => {
-	const engine = new ESLint(options);
+	const files = await globby(
+		patterns,
+		{ignore: ignores, gitignore: true, absolute: true, cwd},
+	);
 
-	const report = await engine.lintFiles(await pFilter(paths, async path => !(await engine.isPathIgnored(path))));
-	return processReport(report, processorOptions);
+	return files.filter(file => extensions.includes(path.extname(file).slice(1)));
 };
 
-const globFiles = async (patterns, {ignores, extensions, cwd}) => (
-	await globby(
-		patterns.length === 0 ? [`**/*.{${extensions.join(',')}}`] : arrify(patterns).map(pattern => slash(pattern)),
-		{ignore: ignores, gitignore: true, absolute: true, cwd},
-	)).filter(file => extensions.includes(path.extname(file).slice(1)));
-
 const getConfig = async options => {
-	const {options: foundOptions, prettierOptions} = mergeWithFileConfig(normalizeOptions(options));
-	const {filePath, warnIgnored, ...eslintOptions} = buildConfig(foundOptions, prettierOptions);
+	const {filePath, eslintOptions} = await parseOptions(options);
 	const engine = new ESLint(eslintOptions);
 	return engine.calculateConfigForFile(filePath);
 };
 
-const lintText = async (string, inputOptions = {}) => {
-	const {options: foundOptions, prettierOptions} = mergeWithFileConfig(normalizeOptions(inputOptions));
-	const options = buildConfig(foundOptions, prettierOptions);
+const lintText = async (string, options) => {
+	options = await parseOptions(options);
+	const {filePath, warnIgnored, eslintOptions, isQuiet} = options;
+	const {cwd, baseConfig: {ignorePatterns}} = eslintOptions;
 
-	if (options.baseConfig.ignorePatterns && !isEqual(getIgnores({}), options.baseConfig.ignorePatterns) && typeof options.filePath !== 'string') {
+	if (typeof filePath !== 'string' && !isEqual(getIgnores({}), ignorePatterns)) {
 		throw new Error('The `ignores` option requires the `filePath` option to be defined.');
 	}
 
-	const {filePath, warnIgnored, ...eslintOptions} = options;
-	const engine = new ESLint(eslintOptions);
-
-	if (filePath) {
-		const filename = path.relative(options.cwd, filePath);
-
-		if (
-			micromatch.isMatch(filename, options.baseConfig.ignorePatterns)
-			|| globby.gitignore.sync({cwd: options.cwd, ignore: options.baseConfig.ignorePatterns})(filePath)
-			|| await engine.isPathIgnored(filePath)
-		) {
-			return {
-				errorCount: 0,
-				warningCount: 0,
-				results: [{
-					errorCount: 0,
-					filePath: filename,
-					messages: [],
-					warningCount: 0,
-				}],
-			};
-		}
+	if (
+		filePath
+		&& (
+			micromatch.isMatch(path.relative(cwd, filePath), ignorePatterns)
+			|| isGitIgnoredSync({cwd, ignore: ignorePatterns})(filePath)
+		)
+	) {
+		return getIgnoredReport(filePath);
 	}
 
-	const report = await engine.lintText(string, {filePath, warnIgnored});
+	const eslint = new ESLint(eslintOptions);
 
-	return processReport(report, {isQuiet: inputOptions.quiet});
+	if (filePath && await eslint.isPathIgnored(filePath)) {
+		return getIgnoredReport(filePath);
+	}
+
+	const report = await eslint.lintText(string, {filePath, warnIgnored});
+	return processReport(report, {isQuiet});
 };
 
-const lintFiles = async (patterns, inputOptions = {}) => {
-	inputOptions.cwd = path.resolve(inputOptions.cwd || process.cwd());
-	const configExplorer = cosmiconfig(MODULE_NAME, {searchPlaces: CONFIG_FILES, loaders: {noExt: defaultLoaders['.json']}, stopDir: inputOptions.cwd});
-
-	const configFiles = (await Promise.all(
-		(await globby(
-			CONFIG_FILES.map(configFile => `**/${configFile}`),
-			{ignore: DEFAULT_IGNORES, gitignore: true, absolute: true, cwd: inputOptions.cwd},
-		)).map(configFile => configExplorer.load(configFile)),
-	)).filter(Boolean);
-
-	const paths = configFiles.length > 0
-		? await pReduce(
-			configFiles,
-			async (paths, {filepath, config}) =>
-				[...paths, ...(await globFiles(patterns, {...mergeOptions(inputOptions, config), cwd: path.dirname(filepath)}))],
-			[])
-		: await globFiles(patterns, mergeOptions(inputOptions));
-
-	return mergeReports(await pMap(await mergeWithFileConfigs([...new Set(paths)], inputOptions, configFiles), async ({files, options, prettierOptions}) => runEslint(files, buildConfig(options, prettierOptions), {isQuiet: options.quiet})));
+const lintFiles = async (patterns, options) => {
+	const files = await globFiles(patterns, options);
+
+	const allOptions = await Promise.all(
+		files.map(filePath => parseOptions({...options, filePath})),
+	);
+
+	// Files with same `xoConfigPath` can lint together
+	// https://github.com/xojs/xo/issues/599
+	const groups = groupBy(allOptions, 'eslintConfigId');
+
+	const reports = await Promise.all(
+		Object.values(groups)
+			.map(async filesWithOptions => {
+				const options = filesWithOptions[0];
+				const eslint = new ESLint(options.eslintOptions);
+				const files = [];
+
+				for (const options of filesWithOptions) {
+					const {filePath, eslintOptions} = options;
+					const {cwd, baseConfig: {ignorePatterns}} = eslintOptions;
+					if (filePath
+						&& (
+							micromatch.isMatch(path.relative(cwd, filePath), ignorePatterns)
+							|| isGitIgnoredSync({cwd, ignore: ignorePatterns})(filePath)
+						)) {
+						continue;
+					}
+
+					// eslint-disable-next-line no-await-in-loop
+					if ((await eslint.isPathIgnored(filePath))) {
+						continue;
+					}
+
+					files.push(filePath);
+				}
+
+				const report = await eslint.lintFiles(files);
+
+				return processReport(report, {isQuiet: options.isQuiet});
+			}));
+
+	const report = mergeReports(reports);
+
+	return report;
 };
 
 const getFormatter = async name => {

package/lib/constants.js

@@ -106,13 +106,6 @@ const ENGINE_RULES = {
 	},
 };
 
-const PRETTIER_CONFIG_OVERRIDE = {
-	'eslint-plugin-babel': 'prettier/babel',
-	'eslint-plugin-flowtype': 'prettier/flowtype',
-	'eslint-plugin-standard': 'prettier/standard',
-	'eslint-plugin-vue': 'prettier/vue',
-};
-
 const MODULE_NAME = 'xo';
 
 const CONFIG_FILES = [
@@ -144,7 +137,6 @@ export {
 	DEFAULT_EXTENSION,
 	TYPESCRIPT_EXTENSION,
 	ENGINE_RULES,
-	PRETTIER_CONFIG_OVERRIDE,
 	MODULE_NAME,
 	CONFIG_FILES,
 	MERGE_OPTIONS_CONCAT,

package/lib/options-manager.js

@@ -1,29 +1,26 @@
+import {existsSync, promises as fs} from 'node:fs';
+import process from 'node:process';
 import os from 'node:os';
 import path from 'node:path';
-import fsExtra from 'fs-extra';
 import arrify from 'arrify';
-import {mergeWith, groupBy, flow, pick} from 'lodash-es';
-import pathExists from 'path-exists';
-import findUp from 'find-up';
+import {mergeWith, flow, pick} from 'lodash-es';
+import {findUpSync} from 'find-up';
 import findCacheDir from 'find-cache-dir';
 import prettier from 'prettier';
 import semver from 'semver';
-import {cosmiconfig, cosmiconfigSync, defaultLoaders} from 'cosmiconfig';
-import pReduce from 'p-reduce';
+import {cosmiconfig, defaultLoaders} from 'cosmiconfig';
 import micromatch from 'micromatch';
 import JSON5 from 'json5';
 import toAbsoluteGlob from 'to-absolute-glob';
 import stringify from 'json-stable-stringify-without-jsonify';
 import murmur from 'imurmurhash';
-import isPathInside from 'is-path-inside';
-import eslintrc from '@eslint/eslintrc';
+import {Legacy} from '@eslint/eslintrc';
 import createEsmUtils from 'esm-utils';
 import {
 	DEFAULT_IGNORES,
 	DEFAULT_EXTENSION,
 	TYPESCRIPT_EXTENSION,
 	ENGINE_RULES,
-	PRETTIER_CONFIG_OVERRIDE,
 	MODULE_NAME,
 	CONFIG_FILES,
 	MERGE_OPTIONS_CONCAT,
@@ -32,10 +29,8 @@ import {
 } from './constants.js';
 
 const {__dirname, json, require} = createEsmUtils(import.meta);
-const pkg = json.loadSync('../package.json');
-const {outputJson, outputJsonSync} = fsExtra;
-const {normalizePackageName} = eslintrc.Legacy.naming;
-const resolveModule = eslintrc.Legacy.ModuleResolver.resolve;
+const {normalizePackageName} = Legacy.naming;
+const resolveModule = Legacy.ModuleResolver.resolve;
 
 const resolveFrom = (moduleId, fromDirectory = process.cwd()) => resolveModule(moduleId, path.join(fromDirectory, '__placeholder__.js'));
 
@@ -48,13 +43,14 @@ resolveFrom.silent = (moduleId, fromDirectory) => {
 const resolveLocalConfig = name => resolveModule(normalizePackageName(name, 'eslint-config'), import.meta.url);
 
 const nodeVersion = process && process.version;
-const cacheLocation = findCacheDir({name: CACHE_DIR_NAME}) || path.join(os.homedir() || os.tmpdir(), '.xo-cache/');
+const cacheLocation = cwd => findCacheDir({name: CACHE_DIR_NAME, cwd}) || path.join(os.homedir() || os.tmpdir(), '.xo-cache/');
 
 const DEFAULT_CONFIG = {
 	useEslintrc: false,
 	cache: true,
-	cacheLocation: path.join(cacheLocation, 'xo-cache.json'),
+	cacheLocation: path.join(cacheLocation(), 'xo-cache.json'),
 	globInputPaths: false,
+	resolvePluginsRelativeTo: __dirname,
 	baseConfig: {
 		extends: [
 			resolveLocalConfig('xo'),
@@ -104,111 +100,90 @@ const isTypescript = file => TYPESCRIPT_EXTENSION.includes(path.extname(file).sl
 Find config for `lintText`.
 The config files are searched starting from `options.filePath` if defined or `options.cwd` otherwise.
 */
-const mergeWithFileConfig = options => {
+const mergeWithFileConfig = async options => {
 	options.cwd = path.resolve(options.cwd || process.cwd());
-	const configExplorer = cosmiconfigSync(MODULE_NAME, {searchPlaces: CONFIG_FILES, loaders: {noExt: defaultLoaders['.json']}, stopDir: options.cwd});
-	const pkgConfigExplorer = cosmiconfigSync('engines', {searchPlaces: ['package.json'], stopDir: options.cwd});
+	const configExplorer = cosmiconfig(MODULE_NAME, {searchPlaces: CONFIG_FILES, loaders: {noExt: defaultLoaders['.json']}, stopDir: options.cwd});
+	const pkgConfigExplorer = cosmiconfig('engines', {searchPlaces: ['package.json'], stopDir: options.cwd});
 	if (options.filePath) {
 		options.filePath = path.resolve(options.cwd, options.filePath);
 	}
 
 	const searchPath = options.filePath || options.cwd;
 
-	const {config: xoOptions, filepath: xoConfigPath} = configExplorer.search(searchPath) || {};
-	const {config: enginesOptions} = pkgConfigExplorer.search(searchPath) || {};
+	const {config: xoOptions, filepath: xoConfigPath} = (await configExplorer.search(searchPath)) || {};
+	const {config: enginesOptions} = (await pkgConfigExplorer.search(searchPath)) || {};
 
 	options = mergeOptions(options, xoOptions, enginesOptions);
 	options.cwd = xoConfigPath && path.dirname(xoConfigPath) !== options.cwd ? path.resolve(options.cwd, path.dirname(xoConfigPath)) : options.cwd;
 
+	// Very simple way to ensure eslint is ran minimal times across
+	// all linted files, once for each unique configuration - xo config path + override hash + tsconfig path
+	let eslintConfigId = xoConfigPath;
 	if (options.filePath) {
-		({options} = applyOverrides(options.filePath, options));
-	}
-
-	const prettierOptions = options.prettier ? prettier.resolveConfig.sync(searchPath, {editorconfig: true}) || {} : {};
-
-	if (options.filePath && isTypescript(options.filePath)) {
-		const tsConfigExplorer = cosmiconfigSync([], {searchPlaces: ['tsconfig.json'], loaders: {'.json': (_, content) => JSON5.parse(content)}});
-		const {config: tsConfig, filepath: tsConfigPath} = tsConfigExplorer.search(options.filePath) || {};
+		const overrides = applyOverrides(options.filePath, options);
+		options = overrides.options;
 
-		options.tsConfigPath = getTsConfigCachePath([options.filePath], options.tsConfigPath);
-		options.ts = true;
-		outputJsonSync(options.tsConfigPath, makeTSConfig(tsConfig, tsConfigPath, [options.filePath]));
+		if (overrides.hash) {
+			eslintConfigId += overrides.hash;
+		}
 	}
 
-	return {options, prettierOptions};
-};
-
-/**
-Find config for each files found by `lintFiles`.
-The config files are searched starting from each files.
-*/
-const mergeWithFileConfigs = async (files, options, configFiles) => {
-	configFiles = configFiles.sort((a, b) => b.filepath.split(path.sep).length - a.filepath.split(path.sep).length);
-	const tsConfigs = {};
-
-	const groups = [...(await pReduce(files, async (configs, file) => {
-		const pkgConfigExplorer = cosmiconfig('engines', {searchPlaces: ['package.json'], stopDir: options.cwd});
-
-		const {config: xoOptions, filepath: xoConfigPath} = findApplicableConfig(file, configFiles) || {};
-		const {config: enginesOptions, filepath: enginesConfigPath} = await pkgConfigExplorer.search(file) || {};
+	const prettierOptions = options.prettier ? await prettier.resolveConfig(searchPath, {editorconfig: true}) || {} : {};
 
-		let fileOptions = mergeOptions(options, xoOptions, enginesOptions);
-		fileOptions.cwd = xoConfigPath && path.dirname(xoConfigPath) !== fileOptions.cwd ? path.resolve(fileOptions.cwd, path.dirname(xoConfigPath)) : fileOptions.cwd;
-
-		const {hash, options: optionsWithOverrides} = applyOverrides(file, fileOptions);
-		fileOptions = optionsWithOverrides;
-
-		const prettierOptions = fileOptions.prettier ? await prettier.resolveConfig(file, {editorconfig: true}) || {} : {};
+	if (options.filePath && isTypescript(options.filePath)) {
+		// We can skip looking up the tsconfig if we have it defined
+		// in our parser options already. Otherwise we can look it up and create it as normal
+		const {project: tsConfigProjectPath, tsconfigRootDir} = options.parserOptions || {};
 
+		let tsConfig;
 		let tsConfigPath;
-		if (isTypescript(file)) {
-			let tsConfig;
-			const tsConfigExplorer = cosmiconfig([], {searchPlaces: ['tsconfig.json'], loaders: {'.json': (_, content) => JSON5.parse(content)}});
-			({config: tsConfig, filepath: tsConfigPath} = await tsConfigExplorer.search(file) || {});
-
-			fileOptions.tsConfigPath = tsConfigPath;
-			tsConfigs[tsConfigPath || ''] = tsConfig;
-			fileOptions.ts = true;
+		if (tsConfigProjectPath) {
+			tsConfigPath = path.resolve(options.cwd, tsConfigProjectPath);
+			tsConfig = await json.load(tsConfigPath);
+		} else {
+			const tsConfigExplorer = cosmiconfig([], {
+				searchPlaces: ['tsconfig.json'],
+				loaders: {'.json': (_, content) => JSON5.parse(content)},
+				stopDir: tsconfigRootDir,
+			});
+			const searchResults = (await tsConfigExplorer.search(options.filePath)) || {};
+			tsConfigPath = searchResults.filepath;
+			tsConfig = searchResults.config;
 		}
 
-		const cacheKey = stringify({xoConfigPath, enginesConfigPath, prettierOptions, hash, tsConfigPath: fileOptions.tsConfigPath, ts: fileOptions.ts});
-		const cachedGroup = configs.get(cacheKey);
-
-		configs.set(cacheKey, {
-			files: [file, ...(cachedGroup ? cachedGroup.files : [])],
-			options: cachedGroup ? cachedGroup.options : fileOptions,
-			prettierOptions,
-		});
-
-		return configs;
-	}, new Map())).values()];
-
-	await Promise.all(Object.entries(groupBy(groups.filter(({options}) => Boolean(options.ts)), group => group.options.tsConfigPath || '')).map(
-		([tsConfigPath, groups]) => {
-			const files = groups.flatMap(group => group.files);
-			const cachePath = getTsConfigCachePath(files, tsConfigPath);
-
-			for (const group of groups) {
-				group.options.tsConfigPath = cachePath;
-			}
+		if (tsConfigPath) {
+			options.tsConfigPath = tsConfigPath;
+			eslintConfigId += tsConfigPath;
+		} else {
+			const {path: tsConfigCachePath, hash: tsConfigHash} = await getTsConfigCachePath([eslintConfigId], tsConfigPath, options.cwd);
+			eslintConfigId += tsConfigHash;
+			options.tsConfigPath = tsConfigCachePath;
+			const config = makeTSConfig(tsConfig, tsConfigPath, [options.filePath]);
+			await fs.mkdir(path.dirname(options.tsConfigPath), {recursive: true});
+			await fs.writeFile(options.tsConfigPath, JSON.stringify(config));
+		}
 
-			return outputJson(cachePath, makeTSConfig(tsConfigs[tsConfigPath], tsConfigPath, files));
-		},
-	));
+		options.ts = true;
+	}
 
-	return groups;
+	return {options, prettierOptions, eslintConfigId};
 };
 
-const findApplicableConfig = (file, configFiles) => configFiles.find(({filepath}) => isPathInside(file, path.dirname(filepath)));
-
 /**
 Generate a unique and consistent path for the temporary `tsconfig.json`.
 Hashing based on https://github.com/eslint/eslint/blob/cf38d0d939b62f3670cdd59f0143fd896fccd771/lib/cli-engine/lint-result-cache.js#L30
 */
-const getTsConfigCachePath = (files, tsConfigPath) => path.join(
-	cacheLocation,
-	`tsconfig.${murmur(`${pkg.version}_${nodeVersion}_${stringify({files: files.sort(), tsConfigPath})}`).result().toString(36)}.json`,
-);
+const getTsConfigCachePath = async (files, tsConfigPath, cwd) => {
+	const {version} = await json.load('../package.json');
+	const tsConfigHash = murmur(`${version}_${nodeVersion}_${stringify({files: files.sort(), tsConfigPath})}`).result().toString(36);
+	return {
+		path: path.join(
+			cacheLocation(cwd),
+			`tsconfig.${tsConfigHash}.json`,
+		),
+		hash: tsConfigHash,
+	};
+};
 
 const makeTSConfig = (tsConfig, tsConfigPath, files) => {
 	const config = {files: files.filter(file => isTypescript(file))};
@@ -270,7 +245,7 @@ const mergeOptions = (options, xoOptions = {}, enginesOptions = {}) => {
 		...options,
 	});
 
-	mergedOptions.extensions = DEFAULT_EXTENSION.concat(mergedOptions.extensions || []);
+	mergedOptions.extensions = [...DEFAULT_EXTENSION, ...(mergedOptions.extensions || [])];
 	mergedOptions.ignores = getIgnores(mergedOptions);
 
 	return mergedOptions;
@@ -413,6 +388,10 @@ const buildXOConfig = options => config => {
 
 		// Does not work when the TS definition exports a default const.
 		config.baseConfig.rules['import/default'] = 'off';
+
+		// Disabled as it doesn't work with TypeScript.
+		// This issue and some others: https://github.com/benmosher/eslint-plugin-import/issues/1341
+		config.baseConfig.rules['import/named'] = 'off';
 	}
 
 	config.baseConfig.settings['import/resolver'] = gatherImportResolvers(options);
@@ -424,7 +403,7 @@ const buildExtendsConfig = options => config => {
 	if (options.extends && options.extends.length > 0) {
 		const configs = options.extends.map(name => {
 			// Don't do anything if it's a filepath
-			if (pathExists.sync(name)) {
+			if (existsSync(name)) {
 				return name;
 			}
 
@@ -453,19 +432,11 @@ const buildPrettierConfig = (options, prettierConfig) => config => {
 		// The prettier plugin uses Prettier to format the code with `--fix`
 		config.baseConfig.plugins.push('prettier');
 
-		// The prettier config overrides ESLint stylistic rules that are handled by Prettier
-		config.baseConfig.extends.push('prettier');
+		// The prettier plugin overrides ESLint stylistic rules that are handled by Prettier
+		config.baseConfig.extends.push('plugin:prettier/recommended');
 
 		// The `prettier/prettier` rule reports errors if the code is not formatted in accordance to Prettier
 		config.baseConfig.rules['prettier/prettier'] = ['error', mergeWithPrettierConfig(options, prettierConfig)];
-
-		// If the user has the React, Flowtype, or Standard plugin, add the corresponding Prettier rule overrides
-		// See https://github.com/prettier/eslint-config-prettier for the list of plugins overrrides
-		for (const [plugin, prettierConfig] of Object.entries(PRETTIER_CONFIG_OVERRIDE)) {
-			if (options.cwd && resolveFrom.silent(plugin, options.cwd)) {
-				config.baseConfig.extends.push(prettierConfig);
-			}
-		}
 	}
 
 	return config;
@@ -491,8 +462,8 @@ const mergeWithPrettierConfig = (options, prettierOptions) => {
 		{
 			singleQuote: true,
 			bracketSpacing: false,
-			jsxBracketSameLine: false,
-			trailingComma: 'none',
+			bracketSameLine: false,
+			trailingComma: 'all',
 			tabWidth: normalizeSpaces(options),
 			useTabs: !options.space,
 			semi: options.semicolon !== false,
@@ -504,7 +475,7 @@ const mergeWithPrettierConfig = (options, prettierOptions) => {
 
 const buildTSConfig = options => config => {
 	if (options.ts) {
-		config.baseConfig.extends.push('xo-typescript');
+		config.baseConfig.extends.push(require.resolve('eslint-config-xo-typescript'));
 		config.baseConfig.parser = require.resolve('@typescript-eslint/parser');
 		config.baseConfig.parserOptions = {
 			...config.baseConfig.parserOptions,
@@ -550,11 +521,11 @@ const findApplicableOverrides = (path, overrides) => {
 	const applicable = [];
 
 	for (const override of overrides) {
-		hash <<= 1;
+		hash <<= 1; // eslint-disable-line no-bitwise
 
 		if (micromatch.isMatch(path, override.files)) {
 			applicable.push(override);
-			hash |= 1;
+			hash |= 1; // eslint-disable-line no-bitwise
 		}
 	}
 
@@ -564,7 +535,7 @@ const findApplicableOverrides = (path, overrides) => {
 	};
 };
 
-const getIgnores = ({ignores}) => DEFAULT_IGNORES.concat(ignores || []);
+const getIgnores = ({ignores}) => [...DEFAULT_IGNORES, ...(ignores || [])];
 
 const gatherImportResolvers = options => {
 	let resolvers = {};
@@ -584,7 +555,7 @@ const gatherImportResolvers = options => {
 		webpackResolverSettings = options.webpack === true ? {} : options.webpack;
 	} else if (!(options.webpack === false || resolvers.webpack)) {
 		// If a webpack config file exists, add the import resolver automatically
-		const webpackConfigPath = findUp.sync('webpack.config.js', {cwd: options.cwd});
+		const webpackConfigPath = findUpSync('webpack.config.js', {cwd: options.cwd});
 		if (webpackConfigPath) {
 			webpackResolverSettings = {config: webpackConfigPath};
 		}
@@ -603,14 +574,28 @@ const gatherImportResolvers = options => {
 	return resolvers;
 };
 
+const parseOptions = async options => {
+	options = normalizeOptions(options);
+	const {options: foundOptions, prettierOptions, eslintConfigId} = await mergeWithFileConfig(options);
+	const {filePath, warnIgnored, ...eslintOptions} = buildConfig(foundOptions, prettierOptions);
+	return {
+		filePath,
+		warnIgnored,
+		isQuiet: options.quiet,
+		eslintOptions,
+		eslintConfigId,
+	};
+};
+
 export {
+	parseOptions,
+	getIgnores,
+	mergeWithFileConfig,
+
+	// For tests
+	applyOverrides,
 	findApplicableOverrides,
 	mergeWithPrettierConfig,
 	normalizeOptions,
-	getIgnores,
-	mergeWithFileConfigs,
-	mergeWithFileConfig,
 	buildConfig,
-	applyOverrides,
-	mergeOptions,
 };

package/lib/report.js

@@ -0,0 +1,84 @@
+import defineLazyProperty from 'define-lazy-prop';
+import {ESLint} from 'eslint';
+
+/** Merge multiple reports into a single report */
+const mergeReports = reports => {
+	const report = {
+		results: [],
+		errorCount: 0,
+		warningCount: 0,
+	};
+
+	for (const currentReport of reports) {
+		report.results.push(...currentReport.results);
+		report.errorCount += currentReport.errorCount;
+		report.warningCount += currentReport.warningCount;
+	}
+
+	return report;
+};
+
+const processReport = (report, {isQuiet = false} = {}) => {
+	if (isQuiet) {
+		report = ESLint.getErrorResults(report);
+	}
+
+	const result = {
+		results: report,
+		...getReportStatistics(report),
+	};
+
+	defineLazyProperty(result, 'usedDeprecatedRules', () => {
+		const seenRules = new Set();
+		const rules = [];
+
+		for (const {usedDeprecatedRules} of report) {
+			for (const rule of usedDeprecatedRules) {
+				if (seenRules.has(rule.ruleId)) {
+					continue;
+				}
+
+				seenRules.add(rule.ruleId);
+				rules.push(rule);
+			}
+		}
+
+		return rules;
+	});
+
+	return result;
+};
+
+const getReportStatistics = results => {
+	const statistics = {
+		errorCount: 0,
+		warningCount: 0,
+		fixableErrorCount: 0,
+		fixableWarningCount: 0,
+	};
+
+	for (const result of results) {
+		statistics.errorCount += result.errorCount;
+		statistics.warningCount += result.warningCount;
+		statistics.fixableErrorCount += result.fixableErrorCount;
+		statistics.fixableWarningCount += result.fixableWarningCount;
+	}
+
+	return statistics;
+};
+
+const getIgnoredReport = filePath => ({
+	errorCount: 0,
+	warningCount: 0,
+	results: [
+		{
+			errorCount: 0,
+			warningCount: 0,
+			filePath,
+			messages: [],
+		},
+	],
+	isIgnored: true,
+});
+
+export {mergeReports, processReport, getIgnoredReport};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xo",
-	"version": "0.42.0",
+	"version": "0.46.0",
 	"description": "JavaScript/TypeScript linter (ESLint wrapper) with great defaults",
 	"license": "MIT",
 	"repository": "xojs/xo",
@@ -16,7 +16,8 @@
 		"node": ">=12.20"
 	},
 	"scripts": {
-		"test": "eslint --quiet . --ext .js,.cjs && nyc ava"
+		"test:clean": "find ./test -type d -name 'node_modules' -prune -not -path ./test/fixtures/project/node_modules -exec rm -rf '{}' +",
+		"test": "node cli.js && nyc ava"
 	},
 	"files": [
 		"config",
@@ -51,75 +52,67 @@
 		"javascript",
 		"typescript"
 	],
+	"bundledDependencies": [
+		"@typescript-eslint/eslint-plugin",
+		"@typescript-eslint/parser",
+		"eslint-config-xo-typescript"
+	],
 	"dependencies": {
-		"@eslint/eslintrc": "^0.4.2",
-		"@typescript-eslint/eslint-plugin": "^4.28.3",
-		"@typescript-eslint/parser": "^4.28.3",
+		"@eslint/eslintrc": "^1.0.3",
+		"@typescript-eslint/eslint-plugin": "^5.2.0",
+		"@typescript-eslint/parser": "^5.2.0",
 		"arrify": "^3.0.0",
-		"cosmiconfig": "^7.0.0",
-		"debug": "^4.3.2",
+		"cosmiconfig": "^7.0.1",
 		"define-lazy-prop": "^3.0.0",
-		"eslint": "^7.30.0",
+		"eslint": "^8.1.0",
 		"eslint-config-prettier": "^8.3.0",
-		"eslint-config-xo": "^0.37.0",
-		"eslint-config-xo-typescript": "^0.43.0",
+		"eslint-config-xo": "^0.39.0",
+		"eslint-config-xo-typescript": "^0.47.0",
 		"eslint-formatter-pretty": "^4.1.0",
-		"eslint-import-resolver-webpack": "^0.13.1",
-		"eslint-plugin-ava": "^12.0.0",
+		"eslint-import-resolver-webpack": "^0.13.2",
+		"eslint-plugin-ava": "^13.1.0",
 		"eslint-plugin-eslint-comments": "^3.2.0",
-		"eslint-plugin-import": "^2.23.4",
+		"eslint-plugin-import": "^2.25.2",
 		"eslint-plugin-no-use-extend-native": "^0.5.0",
 		"eslint-plugin-node": "^11.1.0",
-		"eslint-plugin-prettier": "^3.4.0",
-		"eslint-plugin-promise": "^5.1.0",
-		"eslint-plugin-unicorn": "^34.0.1",
-		"esm-utils": "^1.1.0",
-		"find-cache-dir": "^3.3.1",
-		"find-up": "^5.0.0",
-		"fs-extra": "^10.0.0",
+		"eslint-plugin-prettier": "^4.0.0",
+		"eslint-plugin-unicorn": "^37.0.1",
+		"esm-utils": "^2.0.0",
+		"find-cache-dir": "^3.3.2",
+		"find-up": "^6.2.0",
 		"get-stdin": "^9.0.0",
-		"globby": "^11.0.4",
+		"globby": "^12.0.2",
 		"imurmurhash": "^0.1.4",
-		"is-path-inside": "^4.0.0",
 		"json-stable-stringify-without-jsonify": "^1.0.1",
 		"json5": "^2.2.0",
 		"lodash-es": "^4.17.21",
-		"meow": "^10.1.0",
+		"meow": "^10.1.1",
 		"micromatch": "^4.0.4",
 		"open-editor": "^3.0.0",
-		"p-filter": "^2.1.0",
-		"p-map": "^5.0.0",
-		"p-reduce": "^3.0.0",
-		"path-exists": "^4.0.0",
-		"prettier": "^2.3.2",
+		"prettier": "^2.4.1",
 		"semver": "^7.3.5",
 		"slash": "^4.0.0",
 		"to-absolute-glob": "^2.0.2",
-		"typescript": "^4.3.5"
+		"typescript": "^4.4.4"
 	},
 	"devDependencies": {
 		"ava": "^3.15.0",
 		"eslint-config-xo-react": "^0.25.0",
-		"eslint-plugin-react": "^7.24.0",
+		"eslint-plugin-react": "^7.26.1",
 		"eslint-plugin-react-hooks": "^4.2.0",
 		"execa": "^5.1.1",
 		"nyc": "^15.1.0",
 		"proxyquire": "^2.1.3",
 		"temp-write": "^5.0.0",
-		"webpack": "^5.45.0"
+		"webpack": "^5.60.0"
 	},
-	"eslintConfig": {
-		"extends": [
-			"eslint-config-xo",
-			"./config/plugins.cjs",
-			"./config/overrides.cjs"
+	"xo": {
+		"ignores": [
+			"test/fixtures",
+			"test/temp",
+			"coverage"
 		]
 	},
-	"eslintIgnore": [
-		"test/fixtures",
-		"test/temp",
-		"coverage"
-	],
 	"ava": {
 		"files": [
 			"!test/temp"

package/readme.md

@@ -40,7 +40,7 @@ It uses [ESLint](https://eslint.org) underneath, so issues regarding built-in ru
 ## Install
 
 ```
-$ npm install xo
+$ npm install xo --save-dev
 ```
 
 *You must install XO locally. You can run it directly with `$ npx xo`.*
@@ -169,14 +169,14 @@ module.exports = {
 };
 ```
 
-[Globals](https://eslint.org/docs/user-guide/configuring#specifying-globals) and [rules](https://eslint.org/docs/user-guide/configuring#configuring-rules) can be configured inline in files.
+[Globals](https://eslint.org/docs/user-guide/configuring/language-options#specifying-globals) and [rules](https://eslint.org/docs/user-guide/configuring/rules#configuring-rules) can be configured inline in files.
 
 ### envs
 
 Type: `string[]`\
 Default: `['es2021', 'node']`
 
-Which [environments](https://eslint.org/docs/user-guide/configuring#specifying-environments) your code is designed to run in. Each environment brings with it a certain set of predefined global variables.
+Which [environments](https://eslint.org/docs/user-guide/configuring/language-options#specifying-environments) your code is designed to run in. Each environment brings with it a certain set of predefined global variables.
 
 ### globals
 
@@ -188,7 +188,7 @@ Additional global variables your code accesses during execution.
 
 Type: `string[]`
 
-Some [paths](lib/options-manager.js) are ignored by default, including paths in `.gitignore` and [.eslintignore](https://eslint.org/docs/user-guide/configuring#eslintignore). Additional ignores can be added here.
+Some [paths](lib/options-manager.js) are ignored by default, including paths in `.gitignore` and [.eslintignore](https://eslint.org/docs/user-guide/configuring/ignoring-code#the-eslintignore-file). Additional ignores can be added here.
 
 ### space
 
@@ -221,14 +221,23 @@ Default: `false`
 
 Format code with [Prettier](https://github.com/prettier/prettier).
 
-The [Prettier options](https://prettier.io/docs/en/options.html) will be read from the [Prettier config](https://prettier.io/docs/en/configuration.html) and if **not set** will be determined as follow:
+[Prettier options](https://prettier.io/docs/en/options.html) will be based on your [Prettier config](https://prettier.io/docs/en/configuration.html). XO will then **merge** your options with its own defaults:
 - [semi](https://prettier.io/docs/en/options.html#semicolons): based on [semicolon](#semicolon) option
 - [useTabs](https://prettier.io/docs/en/options.html#tabs): based on [space](#space) option
 - [tabWidth](https://prettier.io/docs/en/options.html#tab-width): based on [space](#space) option
-- [trailingComma](https://prettier.io/docs/en/options.html#trailing-commas): `none`
+- [trailingComma](https://prettier.io/docs/en/options.html#trailing-commas): `all`
 - [singleQuote](https://prettier.io/docs/en/options.html#quotes): `true`
 - [bracketSpacing](https://prettier.io/docs/en/options.html#bracket-spacing): `false`
-- [jsxBracketSameLine](https://prettier.io/docs/en/options.html#jsx-brackets): `false`
+
+To stick with Prettier's defaults, add this to your Prettier config:
+
+```js
+module.exports = {
+	trailingComma: 'es5',
+	singleQuote: false,
+	bracketSpacing: true,
+};
+```
 
 If contradicting options are set for both Prettier and XO an error will be thrown.
 
@@ -245,13 +254,13 @@ If set to `false`, no rules specific to a Node.js version will be enabled.
 
 Type: `string[]`
 
-Include third-party [plugins](https://eslint.org/docs/user-guide/configuring.html#configuring-plugins).
+Include third-party [plugins](https://eslint.org/docs/user-guide/configuring/plugins#configuring-plugins).
 
 ### extends
 
 Type: `string | string[]`
 
-Use one or more [shareable configs](https://eslint.org/docs/developer-guide/shareable-configs.html) or [plugin configs](https://eslint.org/docs/user-guide/configuring#using-the-configuration-from-a-plugin) to override any of the default rules (like `rules` above).
+Use one or more [shareable configs](https://eslint.org/docs/developer-guide/shareable-configs) or [plugin configs](https://eslint.org/docs/user-guide/configuring/configuration-files#using-a-configuration-from-a-plugin) to override any of the default rules (like `rules` above).
 
 ### extensions
 
@@ -263,7 +272,7 @@ Allow more extensions to be linted besides `.js`, `.jsx`, `.mjs`, and `.cjs`. Ma
 
 Type: `object`
 
-[Shared ESLint settings](https://eslint.org/docs/user-guide/configuring#adding-shared-settings) exposed to rules.
+[Shared ESLint settings](https://eslint.org/docs/user-guide/configuring/configuration-files#adding-shared-settings) exposed to rules.
 
 ### parser
 
@@ -275,7 +284,7 @@ ESLint parser. For example, [`@babel/eslint-parser`](https://github.com/babel/ba
 
 Type: `string`
 
-[ESLint processor.](https://eslint.org/docs/user-guide/configuring#specifying-processor)
+[ESLint processor.](https://eslint.org/docs/user-guide/configuring/plugins#specifying-processor)
 
 ### webpack