xo 1.2.3 → 2.0.1

package/dist/cli.d.ts

@@ -4,6 +4,10 @@ declare const cli: import("meow").Result<{
         type: "boolean";
         default: false;
     };
+    fixDryRun: {
+        type: "boolean";
+        default: false;
+    };
     reporter: {
         type: "string";
     };

package/dist/cli.js

@@ -16,6 +16,7 @@ const cli = meow(`
 
   Options
     --fix             Automagically fix issues
+    --fix-dry-run     Automagically fix issues without saving the changes to the file system
     --reporter        Reporter to use
     --space           Use space indent instead of tabs [Default: 2]
     --config          Path to a XO configuration file
@@ -46,6 +47,10 @@ const cli = meow(`
             type: 'boolean',
             default: false,
         },
+        fixDryRun: {
+            type: 'boolean',
+            default: false,
+        },
         reporter: {
             type: 'string',
         },
@@ -105,7 +110,7 @@ const baseXoConfigOptions = {
     react: cliOptions.react,
 };
 const linterOptions = {
-    fix: cliOptions.fix,
+    fix: cliOptions.fix || cliOptions.fixDryRun,
     cwd: (cliOptions.cwd && path.resolve(cliOptions.cwd)) ?? process.cwd(),
     quiet: cliOptions.quiet,
     ts: true,
@@ -171,7 +176,7 @@ if (cliOptions.stdin) {
             await fs.writeFile(cliOptions.stdinFilename, stdin);
         }
     }
-    if (cliOptions.fix) {
+    if (linterOptions.fix) {
         const xo = new Xo(linterOptions, baseXoConfigOptions);
         const { results: [result] } = await xo.lintText(stdin, {
             filePath: cliOptions.stdinFilename,

package/dist/lib/config.js

@@ -3,50 +3,61 @@ import pluginUnicorn from 'eslint-plugin-unicorn';
 import pluginImport from 'eslint-plugin-import-x';
 import pluginN from 'eslint-plugin-n';
 import pluginComments from '@eslint-community/eslint-plugin-eslint-comments';
-import pluginPromise from 'eslint-plugin-promise';
-import pluginNoUseExtendNative from 'eslint-plugin-no-use-extend-native';
+/// import pluginPromise from 'eslint-plugin-promise';
 import configXoTypescript from 'eslint-config-xo-typescript';
-import stylisticPlugin from '@stylistic/eslint-plugin';
 import globals from 'globals';
+import { fixupPluginRules } from '@eslint/compat';
 import { defaultIgnores, tsExtensions, tsFilesGlob, allFilesGlob, jsExtensions, allExtensions, } from './constants.js';
-if (Array.isArray(pluginAva?.configs?.['recommended'])) {
-    throw new TypeError('Invalid eslint-plugin-ava');
-}
-if (!configXoTypescript[1]) {
+import noUseExtendNativeRule from './rules/no-use-extend-native.js';
+if (!configXoTypescript[4]) {
     throw new Error('Invalid eslint-config-xo-typescript');
 }
+const baseLanguageOptions = configXoTypescript[0]?.languageOptions;
+const baseParserOptions = baseLanguageOptions?.parserOptions ?? {};
+const typescriptLanguageOptions = (configXoTypescript[4]?.languageOptions ?? {});
+const typescriptParserOptions = typescriptLanguageOptions.parserOptions ?? {};
+const pluginNoUseExtendNative = {
+    rules: {
+        'no-use-extend-native': noUseExtendNativeRule,
+    },
+};
+// TODO: Remove `fixupPluginRules` wrapping when these plugins support ESLint 10 natively.
+const fixedUpBasePlugins = Object.fromEntries(Object.entries(configXoTypescript[0]?.plugins ?? {}).map(([key, plugin]) => [key, fixupPluginRules(plugin)]));
+const fixedUpTypescriptPlugins = Object.fromEntries(Object.entries(configXoTypescript[4]?.plugins ?? {}).map(([key, plugin]) => [key, fixupPluginRules(plugin)]));
 /**
 The base config that XO builds on top of from user options.
 */
 export const config = [
     {
-        name: 'XO Default Ignores',
+        name: 'xo/ignores',
         ignores: defaultIgnores,
     },
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    ...pluginAva.configs['recommended'],
     {
-        name: 'XO',
-        files: [
-            allFilesGlob,
-        ],
+        name: 'xo/base',
+        files: [allFilesGlob],
         plugins: {
+            ...fixedUpBasePlugins,
+            ...fixedUpTypescriptPlugins,
             'no-use-extend-native': pluginNoUseExtendNative,
             ava: pluginAva,
             unicorn: pluginUnicorn,
             'import-x': pluginImport,
-            n: pluginN,
             '@eslint-community/eslint-comments': pluginComments,
-            promise: pluginPromise,
-            '@stylistic': stylisticPlugin, // eslint-disable-line @typescript-eslint/naming-convention
+            // TODO: Remove `fixupPluginRules` wrapping when these plugins support ESLint 10 natively.
+            n: fixupPluginRules(pluginN),
+            /// promise: fixupPluginRules(pluginPromise),
         },
         languageOptions: {
             globals: {
                 ...globals.es2021,
                 ...globals.node,
             },
-            ecmaVersion: configXoTypescript[0]?.languageOptions?.ecmaVersion,
-            sourceType: configXoTypescript[0]?.languageOptions?.sourceType,
+            ecmaVersion: baseLanguageOptions?.ecmaVersion,
+            sourceType: baseLanguageOptions?.sourceType,
             parserOptions: {
-                ...configXoTypescript[0]?.languageOptions?.parserOptions,
+                ...baseParserOptions,
             },
         },
         settings: {
@@ -71,7 +82,6 @@ export const config = [
         These are the base rules that are always applied to all js and ts file types
         */
         rules: {
-            ...pluginAva?.configs?.['recommended']?.rules,
             ...pluginUnicorn.configs?.recommended?.rules,
             'no-use-extend-native/no-use-extend-native': 'error',
             // TODO: Remove this override at some point.
@@ -203,23 +213,24 @@ export const config = [
             'unicorn/no-useless-undefined': 'off',
             // 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/prefer-await-to-then': [
-                'error',
-                {
-                    strict: true,
-                },
-            ],
-            'promise/prefer-catch': 'error',
-            'promise/valid-params': 'error',
+            // Commented out because it's not ready for ESLint 10.
+            // 'promise/param-names': 'error',
+            // 'promise/no-return-wrap': [
+            // 	'error',
+            // 	{
+            // 		allowReject: true,
+            // 	},
+            // ],
+            // 'promise/no-new-statics': 'error',
+            // 'promise/no-return-in-finally': 'error',
+            // 'promise/prefer-await-to-then': [
+            // 	'error',
+            // 	{
+            // 		strict: true,
+            // 	},
+            // ],
+            // 'promise/prefer-catch': 'error',
+            // 'promise/valid-params': 'error',
             'import-x/default': 'error',
             'import-x/export': 'error',
             'import-x/extensions': [
@@ -362,17 +373,22 @@ export const config = [
         },
     },
     {
-        name: 'Xo TypeScript',
-        plugins: configXoTypescript[1]?.plugins,
+        name: 'xo/typescript',
+        plugins: fixedUpTypescriptPlugins,
         files: [tsFilesGlob],
         languageOptions: {
-            ...configXoTypescript[1]?.languageOptions,
+            ...typescriptLanguageOptions,
+            parserOptions: {
+                ...typescriptParserOptions,
+                // This needs to be explicitly set to `true`
+                projectService: true,
+            },
         },
         /**
         This turns on rules in `typescript-eslint`` and turns off rules from ESLint that conflict.
         */
         rules: {
-            ...configXoTypescript[1]?.rules,
+            ...configXoTypescript[4]?.rules,
             'unicorn/import-style': 'off',
             'n/file-extension-in-import': 'off',
             // Disabled because of https://github.com/benmosher/eslint-plugin-import-x/issues/1590
@@ -384,7 +400,7 @@ export const config = [
             'import-x/named': 'off',
         },
     },
-    ...configXoTypescript.slice(2),
+    ...configXoTypescript.slice(5),
     {
         files: ['xo.config.{js,ts}'],
         rules: {

package/dist/lib/handle-ts-files.d.ts

@@ -1,15 +1,18 @@
+import ts from 'typescript';
 /**
 This function checks if the files are matched by the tsconfig include, exclude, and it returns the unmatched files.
 
-If no tsconfig is found, it will create a fallback tsconfig file in the `node_modules/.cache/xo` directory.
+If no tsconfig is found, it will create an in-memory TypeScript Program for type-aware linting.
 
 @param options
-@returns The unmatched files.
+@returns The unmatched files and an in-memory TypeScript Program.
 */
-export declare function handleTsconfig({ cwd, files }: {
-    cwd: string;
+export declare function handleTsconfig({ files, cwd, cacheLocation }: {
     files: string[];
-}): Promise<{
-    unincludedFiles: string[];
-    fallbackTsConfigPath: string;
-}>;
+    cwd: string;
+    cacheLocation?: string;
+}): {
+    existingFiles: string[];
+    virtualFiles: string[];
+    program: ts.Program | undefined;
+};

package/dist/lib/handle-ts-files.js

@@ -1,39 +1,113 @@
 import path from 'node:path';
-import fs from 'node:fs/promises';
+import fs from 'node:fs';
+import ts from 'typescript';
 import { getTsconfig, createFilesMatcher } from 'get-tsconfig';
-import { tsconfigDefaults as tsConfig, cacheDirName } from './constants.js';
+import { tsconfigDefaults } from './constants.js';
+const createInMemoryProgram = (files, cwd) => {
+    if (files.length === 0) {
+        return undefined;
+    }
+    try {
+        const compilerOptions = getFallbackCompilerOptions(cwd);
+        const program = ts.createProgram(files, { ...compilerOptions });
+        Object.defineProperty(program, 'toJSON', {
+            value: () => ({
+                __type: 'TypeScriptProgram',
+                files: files.map(file => path.relative(cwd, file)),
+            }),
+            configurable: true,
+        });
+        return program;
+    }
+    catch (error) {
+        console.warn('XO: Failed to create TypeScript Program for type-aware linting. Continuing without type information for unincluded files.', error instanceof Error ? error.message : String(error));
+        return undefined;
+    }
+};
+const fallbackCompilerOptionsCache = new Map();
+const getFallbackCompilerOptions = (cwd) => {
+    const cacheKey = path.resolve(cwd);
+    const cached = fallbackCompilerOptionsCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const compilerOptionsResult = ts.convertCompilerOptionsFromJson(tsconfigDefaults.compilerOptions ?? {}, cacheKey);
+    if (compilerOptionsResult.errors.length > 0) {
+        throw new Error('XO: Invalid default TypeScript compiler options');
+    }
+    const compilerOptions = {
+        ...compilerOptionsResult.options,
+        esModuleInterop: true,
+        resolveJsonModules: true,
+        allowJs: true,
+        skipLibCheck: true,
+        skipDefaultLibCheck: true,
+    };
+    fallbackCompilerOptionsCache.set(cacheKey, compilerOptions);
+    return compilerOptions;
+};
 /**
 This function checks if the files are matched by the tsconfig include, exclude, and it returns the unmatched files.
 
-If no tsconfig is found, it will create a fallback tsconfig file in the `node_modules/.cache/xo` directory.
+If no tsconfig is found, it will create an in-memory TypeScript Program for type-aware linting.
 
 @param options
-@returns The unmatched files.
+@returns The unmatched files and an in-memory TypeScript Program.
 */
-export async function handleTsconfig({ cwd, files }) {
+export function handleTsconfig({ files, cwd, cacheLocation }) {
     const unincludedFiles = [];
+    const filesMatcherCache = new Map();
     for (const filePath of files) {
         const result = getTsconfig(filePath);
         if (!result) {
             unincludedFiles.push(filePath);
             continue;
         }
-        const filesMatcher = createFilesMatcher(result);
+        const cacheKey = result.path ? path.resolve(result.path) : filePath;
+        let filesMatcher = filesMatcherCache.get(cacheKey);
+        if (!filesMatcher) {
+            filesMatcher = createFilesMatcher(result);
+            filesMatcherCache.set(cacheKey, filesMatcher);
+        }
         if (filesMatcher(filePath)) {
             continue;
         }
         unincludedFiles.push(filePath);
     }
-    const fallbackTsConfigPath = path.join(cwd, 'node_modules', '.cache', cacheDirName, 'tsconfig.xo.json');
-    tsConfig.files = unincludedFiles;
-    if (unincludedFiles.length > 0) {
-        try {
-            await fs.writeFile(fallbackTsConfigPath, JSON.stringify(tsConfig, null, 2));
+    if (unincludedFiles.length === 0) {
+        return { existingFiles: [], virtualFiles: [], program: undefined };
+    }
+    // Separate real files from virtual/cache files
+    // Virtual files include: stdin files (in cache dir), non-existent files
+    // TypeScript will surface opaque diagnostics for missing files; pre-filter so we only pay the program cost for real files.
+    const existingFiles = [];
+    const virtualFiles = [];
+    for (const file of unincludedFiles) {
+        const fileExists = fs.existsSync(file);
+        // Files that don't exist are always virtual
+        if (!fileExists) {
+            virtualFiles.push(file);
+            continue;
         }
-        catch (error) {
-            console.error(error);
+        // Check if file is in cache directory (like stdin files)
+        // These need tsconfig treatment even though they exist on disk
+        if (cacheLocation) {
+            const absolutePath = path.resolve(file);
+            const cacheRoot = path.resolve(cacheLocation);
+            const relativeToCache = path.relative(cacheRoot, absolutePath);
+            // File is inside cache if relative path doesn't escape (no '..')
+            const isInCache = !relativeToCache.startsWith('..') && !path.isAbsolute(relativeToCache);
+            if (isInCache) {
+                virtualFiles.push(file);
+                continue;
+            }
         }
+        existingFiles.push(file);
     }
-    return { unincludedFiles, fallbackTsConfigPath };
+    return {
+        existingFiles,
+        virtualFiles,
+        program: createInMemoryProgram(existingFiles, cwd),
+    };
 }
 //# sourceMappingURL=handle-ts-files.js.map

package/dist/lib/open-report.js

@@ -2,7 +2,7 @@ import openEditor from 'open-editor';
 const sortResults = (a, b) => a.errorCount + b.errorCount > 0 ? (a.errorCount - b.errorCount) : (a.warningCount - b.warningCount);
 const resultToFile = (result) => {
     const [message] = result.messages
-        .sort((a, b) => {
+        .toSorted((a, b) => {
         if (a.severity < b.severity) {
             return 1;
         }
@@ -25,7 +25,7 @@ const resultToFile = (result) => {
 };
 const getFiles = (report, predicate) => report.results
     .filter(result => predicate(result))
-    .sort(sortResults)
+    .toSorted(sortResults)
     .map(result => resultToFile(result));
 const openReport = async (report) => {
     const count = report.errorCount > 0 ? 'errorCount' : 'warningCount';

package/dist/lib/resolve-config.js

@@ -17,14 +17,11 @@ export async function resolveXoConfig(options) {
             searchPlaces: [
                 'package.json',
                 `${moduleName}.config.js`,
-                `${moduleName}.config.cjs`,
                 `${moduleName}.config.mjs`,
                 `${moduleName}.config.ts`,
-                `${moduleName}.config.cts`,
                 `${moduleName}.config.mts`,
             ],
             loaders: {
-                '.cts': defaultLoaders['.ts'], // eslint-disable-line @typescript-eslint/naming-convention
                 '.mts': defaultLoaders['.ts'], // eslint-disable-line @typescript-eslint/naming-convention
             },
             stopDir: stopDirectory,
@@ -33,7 +30,9 @@ export async function resolveXoConfig(options) {
         options.filePath &&= path.resolve(options.cwd, options.filePath);
         const searchPath = options.filePath ?? options.cwd;
         let { config: flatOptions = [], filepath: flatConfigPath = '', } = await (options.configPath
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             ? flatConfigExplorer.load(path.resolve(options.cwd, options.configPath))
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             : flatConfigExplorer.search(searchPath)) ?? {};
         flatOptions = arrify(flatOptions);
         return {

package/dist/lib/rules/no-use-extend-native.d.ts

@@ -0,0 +1,3 @@
+import { type Rule } from 'eslint';
+declare const noUseExtendNativeRule: Rule.RuleModule;
+export default noUseExtendNativeRule;