xo 1.2.3 → 2.0.0

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/types.d.ts

@@ -71,9 +71,11 @@ export type XoConfigItem = Simplify<XoConfigOptions & Omit<Linter.Config, 'files
     /**
     An array of glob patterns indicating the files that the configuration object should apply to. If not specified, the configuration object applies to all files.
 
+    Accepts a single glob string, an array of globs, or ESLint's native format where nested arrays create AND patterns.
+
     @see [Ignore Patterns](https://eslint.org/docs/latest/user-guide/configuring/configuration-files-new#excluding-files-with-ignores)
     */
-    files?: string | string[] | undefined;
+    files?: string | Array<string | string[]> | undefined;
     /**
     An array of glob patterns indicating the files that the configuration object should not apply to. If not specified, the configuration object applies to all files matched by files.
 

package/dist/lib/utils.d.ts

@@ -1,6 +1,6 @@
 import { type Linter } from 'eslint';
-import { type SetRequired } from 'type-fest';
 import { type XoConfigItem } from './types.js';
+export declare const typescriptParser: Linter.Parser | undefined;
 /**
 Convert a `xo` config item to an ESLint config item.
 
@@ -11,7 +11,7 @@ Files and rules will always be defined and all other ESLint config properties ar
 @param xoConfig
 @returns eslintConfig
 */
-export declare const xoToEslintConfigItem: (xoConfig: XoConfigItem) => SetRequired<Linter.Config, "rules" | "files">;
+export declare const xoToEslintConfigItem: (xoConfig: XoConfigItem) => Linter.Config;
 /**
 Function used to match files which should be included in the `tsconfig.json` files.
 
@@ -21,7 +21,7 @@ Function used to match files which should be included in the `tsconfig.json` fil
 @param ignores - The globs to ignore when matching the files.
 @returns An array of file paths that match the globs and do not match the ignores.
 */
-export declare const matchFilesForTsConfig: (cwd: string, files: string[], globs: string[], ignores: string[]) => string[];
+export declare const matchFilesForTsConfig: (cwd: string, files: string[] | undefined, globs: string[], ignores: string[]) => string[];
 /**
 Once a config is resolved, it is pre-processed to ensure that all properties are set correctly.
 

package/dist/lib/utils.js

@@ -3,6 +3,14 @@ import micromatch from 'micromatch';
 import arrify from 'arrify';
 import configXoTypescript from 'eslint-config-xo-typescript';
 import { allFilesGlob, jsExtensions, jsFilesGlob, } from './constants.js';
+const typescriptParserConfig = configXoTypescript.find(config => {
+    const languageOptions = config.languageOptions;
+    return languageOptions?.parser;
+});
+export const typescriptParser = typescriptParserConfig?.languageOptions?.parser;
+if (!typescriptParser) {
+    throw new Error('XO: Failed to locate TypeScript parser in eslint-config-xo-typescript');
+}
 /**
 Convert a `xo` config item to an ESLint config item.
 
@@ -17,8 +25,8 @@ export const xoToEslintConfigItem = (xoConfig) => {
     const { files, rules, space, prettier, ignores, semicolon, react, ..._xoConfig } = xoConfig;
     const eslintConfig = {
         ..._xoConfig,
-        files: arrify(xoConfig.files ?? allFilesGlob),
-        rules: xoConfig.rules ?? {},
+        ...(xoConfig.files ? { files: arrify(xoConfig.files) } : {}),
+        ...(xoConfig.rules ? { rules: xoConfig.rules } : {}),
     };
     eslintConfig.ignores &&= arrify(xoConfig.ignores);
     return eslintConfig;
@@ -32,7 +40,7 @@ Function used to match files which should be included in the `tsconfig.json` fil
 @param ignores - The globs to ignore when matching the files.
 @returns An array of file paths that match the globs and do not match the ignores.
 */
-export const matchFilesForTsConfig = (cwd, files, globs, ignores) => micromatch(files.map(file => path.normalize(path.relative(cwd, file))), 
+export const matchFilesForTsConfig = (cwd, files, globs, ignores) => micromatch(files?.map(file => path.normalize(path.relative(cwd, file))) ?? [], 
 // https://github.com/micromatch/micromatch/issues/217
 globs.map(glob => path.normalize(glob)), {
     dot: true,
@@ -47,11 +55,14 @@ This includes ensuring that user-defined properties can override XO defaults, an
 @param xoConfig - The flat XO config to pre-process.
 @returns The pre-processed flat XO config.
 */
+// eslint-disable-next-line complexity
 export const preProcessXoConfig = (xoConfig) => {
     const tsFilesGlob = [];
     const tsFilesIgnoresGlob = [];
     const processedConfig = [];
     for (const [idx, { ...config }] of xoConfig.entries()) {
+        const languageOptions = config.languageOptions;
+        const parserOptions = languageOptions?.parserOptions;
         // We can skip the first config  item, as it is the base config item.
         if (idx === 0) {
             processedConfig.push(config);
@@ -60,8 +71,10 @@ export const preProcessXoConfig = (xoConfig) => {
         // Use TS parser/plugin for JS files if the config contains TypeScript rules which are applied to JS files.
         // typescript-eslint rules set to "off" are ignored and not applied to JS files.
         if (config.rules
-            && !config.languageOptions?.parser
-            && !config.languageOptions?.parserOptions?.['project']
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            && !languageOptions?.['parser']
+            && parserOptions?.project === undefined
+            && parserOptions?.programs === undefined
             && !config.plugins?.['@typescript-eslint']) {
             const hasTsRules = Object.entries(config.rules).some(rulePair => {
                 // If its not a @typescript-eslint rule, we don't care
@@ -77,7 +90,7 @@ export const preProcessXoConfig = (xoConfig) => {
             if (hasTsRules) {
                 let isAppliedToJsFiles = false;
                 if (config.files) {
-                    const normalizedFiles = arrify(config.files).map(file => path.normalize(file));
+                    const normalizedFiles = arrify(config.files).flat().map(file => path.normalize(file));
                     // Strip the basename off any globs
                     const globs = normalizedFiles.map(file => micromatch.scan(file, { dot: true }).glob).filter(Boolean);
                     // Check if the files globs match a test file with a js extension
@@ -89,25 +102,27 @@ export const preProcessXoConfig = (xoConfig) => {
                     isAppliedToJsFiles = true;
                 }
                 if (isAppliedToJsFiles) {
-                    config.languageOptions ??= {};
+                    const updatedLanguageOptions = languageOptions
+                        ? { ...languageOptions, parser: typescriptParser }
+                        : { parser: typescriptParser };
+                    config.languageOptions = updatedLanguageOptions;
                     config.plugins ??= {};
                     config.plugins = {
                         ...config.plugins,
                         ...configXoTypescript[1]?.plugins,
                     };
-                    config.languageOptions.parser = configXoTypescript[1]?.languageOptions?.parser;
-                    tsFilesGlob.push(...arrify(config.files ?? allFilesGlob));
+                    tsFilesGlob.push(...arrify(config.files ?? allFilesGlob).flat());
                     tsFilesIgnoresGlob.push(...arrify(config.ignores));
                 }
             }
         }
-        // If a user sets the `parserOptions.project` or `projectService` or `tsconfigRootDir`, we need to ensure that the tsFilesGlob is set to exclude those files,
-        // as this indicates the user has opted out of the default TypeScript handling for those files.
-        if (config.languageOptions?.parserOptions?.['project'] !== undefined
-            || config.languageOptions?.parserOptions?.['projectService'] !== undefined
-            || config.languageOptions?.parserOptions?.['tsconfigRootDir'] !== undefined) {
+        // If the config sets `parserOptions.project`, `projectService`, `tsconfigRootDir`, or `programs`, treat those files as opt-out for XO's automatic program wiring.
+        if (parserOptions?.project !== undefined
+            || parserOptions?.projectService !== undefined
+            || parserOptions?.tsconfigRootDir !== undefined
+            || parserOptions?.programs !== undefined) {
             // The glob itself should NOT be negated
-            tsFilesIgnoresGlob.push(...arrify(config.files ?? allFilesGlob));
+            tsFilesIgnoresGlob.push(...arrify(config.files ?? allFilesGlob).flat());
         }
         processedConfig.push(config);
     }

package/dist/lib/xo-to-eslint.js

@@ -4,13 +4,57 @@ import arrify from 'arrify';
 import configReact from 'eslint-config-xo-react';
 import pluginPrettier from 'eslint-plugin-prettier';
 import eslintConfigPrettier from 'eslint-config-prettier';
+import { fixupConfigRules, fixupPluginRules } from '@eslint/compat';
 import { config } from './config.js';
 import { xoToEslintConfigItem } from './utils.js';
 /**
+Merge all plugins from every config into a single config entry at the start of the array, ensuring user-provided plugins take precedence. This avoids ESLint's flat config rejecting duplicate plugin names.
+*/
+const hoistPlugins = (configs, userPluginOverrides) => {
+    const plugins = {};
+    const configsWithoutPlugins = [];
+    for (const configItem of configs) {
+        const { plugins: configPlugins } = configItem;
+        if (!configPlugins) {
+            configsWithoutPlugins.push(configItem);
+            continue;
+        }
+        // ESLint flat config rejects duplicate plugin names, so merge all plugins into one config.
+        Object.assign(plugins, configPlugins);
+        const { plugins: _ignored, ...configWithoutPlugins } = configItem;
+        if (Object.keys(configWithoutPlugins).length > 0) {
+            configsWithoutPlugins.push(configWithoutPlugins);
+        }
+    }
+    for (const [pluginName, plugin] of userPluginOverrides) {
+        plugins[pluginName] = plugin;
+    }
+    if (Object.keys(plugins).length === 0) {
+        return configsWithoutPlugins;
+    }
+    return [
+        {
+            name: 'xo/plugins',
+            plugins,
+        },
+        ...configsWithoutPlugins,
+    ];
+};
+/**
 Takes a XO flat config and returns an ESlint flat config.
 */
 export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
     const baseConfig = [...config];
+    const userPluginOverrides = new Map();
+    for (const xoConfigItem of flatXoConfig ?? []) {
+        const { plugins } = xoConfigItem;
+        if (!plugins) {
+            continue;
+        }
+        for (const [pluginName, plugin] of Object.entries(plugins)) {
+            userPluginOverrides.set(pluginName, plugin);
+        }
+    }
     /**
     Since configs are merged and the last config takes precedence this means we need to handle both true AND false cases for each option. For example, we need to turn `prettier`, `space`, `semi`, etc. on or off for a specific file.
     */
@@ -35,6 +79,7 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         */
         const eslintConfigItem = xoToEslintConfigItem(xoConfigItem);
         if (xoConfigItem.semicolon === false) {
+            eslintConfigItem.rules ??= {};
             eslintConfigItem.rules['@stylistic/semi'] = ['error', 'never'];
             eslintConfigItem.rules['@stylistic/semi-spacing'] = [
                 'error',
@@ -43,6 +88,7 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         }
         if (xoConfigItem.space) {
             const spaces = typeof xoConfigItem.space === 'number' ? xoConfigItem.space : 2;
+            eslintConfigItem.rules ??= {};
             eslintConfigItem.rules['@stylistic/indent'] = [
                 'error',
                 spaces,
@@ -54,12 +100,14 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         else if (xoConfigItem.space === false) {
             // If a user sets this to false for a small subset of files for some reason,
             // then we need to set them back to their original values.
+            eslintConfigItem.rules ??= {};
             eslintConfigItem.rules['@stylistic/indent'] = configXoTypescript[1]?.rules?.['@stylistic/indent'];
             eslintConfigItem.rules['@stylistic/indent-binary-ops'] = configXoTypescript[1]?.rules?.['@stylistic/indent-binary-ops'];
         }
         if (xoConfigItem.react) {
             // Ensure the files applied to the React config are the same as the config they are derived from
-            baseConfig.push({ ...configReact[0], files: eslintConfigItem.files });
+            // TODO: Remove `fixupConfigRules` wrapping when eslint-config-xo-react supports ESLint 10 natively.
+            baseConfig.push({ ...fixupConfigRules(configReact)[0], files: eslintConfigItem.files, name: 'xo/react' });
         }
         // Prettier should generally be the last config in the array
         if (xoConfigItem.prettier) {
@@ -68,7 +116,7 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
             }
             else {
                 // Validate that Prettier options match other `xoConfig` options.
-                /* eslint-disable-next-line */
+                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
                 if ((xoConfigItem.semicolon && prettierOptions.semi === false) || (!xoConfigItem.semicolon && prettierOptions.semi === true)) {
                     throw new Error(`The Prettier config \`semi\` is ${prettierOptions.semi} while Xo \`semicolon\` is ${xoConfigItem.semicolon}, also check your .editorconfig for inconsistencies.`);
                 }
@@ -79,9 +127,10 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
                     throw new Error(`The Prettier config \`tabWidth\` is ${prettierOptions.tabWidth} while Xo \`space\` is ${xoConfigItem.space}, also check your .editorconfig for inconsistencies.`);
                 }
                 // Add Prettier plugin
+                // TODO: Remove `fixupPluginRules` wrapping when eslint-plugin-prettier supports ESLint 10 natively.
                 eslintConfigItem.plugins = {
                     ...eslintConfigItem.plugins,
-                    prettier: pluginPrettier,
+                    prettier: fixupPluginRules(pluginPrettier),
                 };
                 const prettierConfig = {
                     singleQuote: true,
@@ -96,6 +145,7 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
                 // Configure Prettier rules
                 const rulesWithPrettier = {
                     ...eslintConfigItem.rules,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                     ...pluginPrettier.configs?.['recommended']?.rules,
                     // eslint-disable-next-line @typescript-eslint/naming-convention
                     'prettier/prettier': ['error', prettierConfig],
@@ -106,11 +156,16 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         }
         else if (xoConfigItem.prettier === false) {
             // Turn Prettier off for a subset of files
+            eslintConfigItem.rules ??= {};
             eslintConfigItem.rules['prettier/prettier'] = 'off';
         }
+        if (Object.keys(eslintConfigItem).length === 0) {
+            continue;
+        }
         baseConfig.push(eslintConfigItem);
     }
-    return baseConfig;
+    // User plugins should always win, even if XO injects plugins later in the config list.
+    return hoistPlugins(baseConfig, userPluginOverrides);
 }
 export default xoToEslintConfig;
 //# sourceMappingURL=xo-to-eslint.js.map

package/dist/lib/xo.d.ts

@@ -2,6 +2,7 @@ import { ESLint, type Linter } from 'eslint';
 import prettier from 'prettier';
 import { type XoLintResult, type LinterOptions, type LintTextOptions, type XoConfigOptions, type XoConfigItem } from './types.js';
 import { xoToEslintConfig } from './xo-to-eslint.js';
+export declare const ignoredFileWarningMessage = "File ignored because of a matching ignore pattern.";
 export declare class Xo {
     /**
     Static helper to convert an XO config to an ESLint config to be used in `eslint.config.js`.
@@ -65,6 +66,21 @@ export declare class Xo {
     We use this to also add negative glob patterns in case a user overrides the parserOptions in their XO config.
     */
     tsFilesIgnoresGlob: string[];
+    /**
+    Track whether ignores have been added to prevent duplicate ignore configs.
+    */
+    private ignoresHandled;
+    /**
+    Store per-file configs separately from base config to prevent unbounded array growth.
+    Key: file path, Value: config for that file.
+    This prevents memory bloat in long-running processes (e.g., language servers).
+    */
+    private readonly fileConfigs;
+    /**
+    Track virtual/stdin files that share a single tsconfig.stdin.json.
+    These are handled differently from regular files.
+    */
+    private readonly virtualFiles;
     constructor(_linterOptions: LinterOptions, _baseXoConfig?: XoConfigOptions);
     /**
     Sets the XO config on the XO instance.
@@ -91,7 +107,7 @@ export declare class Xo {
     */
     ensureCacheDirectory(): Promise<void>;
     /**
-    Checks every TS file to ensure its included in the tsconfig and any that are not included are added to a generated tsconfig for type aware linting.
+    Checks every TS file to ensure its included in the tsconfig and any that are not included are added to an in-memory TypeScript Program for type aware linting.
 
     @param files - The TypeScript files being linted.
     */
@@ -113,6 +129,14 @@ export declare class Xo {
     lintText(code: string, lintTextOptions: LintTextOptions): Promise<XoLintResult>;
     calculateConfigForFile(filePath: string): Promise<Linter.Config>;
     getFormatter(name: string): Promise<ESLint.LoadedFormatter>;
+    /**
+    Add virtual files to the config with a tsconfig approach.
+    */
+    private addVirtualFilesToConfig;
+    /**
+    Add existing files to the config with an in-memory TypeScript Program.
+    */
+    private addExistingFilesToConfig;
     private processReport;
     private getReportStatistics;
 }

package/dist/lib/xo.js

@@ -1,18 +1,62 @@
 import path from 'node:path';
 import os from 'node:os';
+import syncFs from 'node:fs';
 import fs from 'node:fs/promises';
 import process from 'node:process';
 import { ESLint } from 'eslint';
 import findCacheDirectory from 'find-cache-directory';
-import { globby } from 'globby';
+import { globby, isDynamicPattern } from 'globby';
 import arrify from 'arrify';
 import defineLazyProperty from 'define-lazy-prop';
 import prettier from 'prettier';
-import { defaultIgnores, cacheDirName, allExtensions, tsFilesGlob, } from './constants.js';
+import { defaultIgnores, cacheDirName, allExtensions, tsFilesGlob, tsconfigDefaults, } from './constants.js';
 import { xoToEslintConfig } from './xo-to-eslint.js';
 import resolveXoConfig from './resolve-config.js';
 import { handleTsconfig } from './handle-ts-files.js';
-import { matchFilesForTsConfig, preProcessXoConfig } from './utils.js';
+import { matchFilesForTsConfig, preProcessXoConfig, typescriptParser, } from './utils.js';
+export const ignoredFileWarningMessage = 'File ignored because of a matching ignore pattern.';
+const createIgnoredLintResult = (filePath) => ({
+    filePath,
+    messages: [
+        {
+            ruleId: null,
+            severity: 1,
+            message: ignoredFileWarningMessage,
+            line: 0,
+            column: 0,
+        },
+    ],
+    suppressedMessages: [],
+    errorCount: 0,
+    fatalErrorCount: 0,
+    warningCount: 1,
+    fixableErrorCount: 0,
+    fixableWarningCount: 0,
+    usedDeprecatedRules: [],
+});
+const resolveExplicitFilePath = (cwd, glob) => {
+    if (isDynamicPattern(glob)) {
+        // Negated and wildcard globs are treated as regular glob filtering, not as explicit file paths that should trigger an ignored-file warning.
+        return undefined;
+    }
+    const absolutePath = path.resolve(cwd, glob);
+    try {
+        if (syncFs.statSync(absolutePath).isFile()) {
+            return absolutePath;
+        }
+    }
+    catch {
+        // File does not exist or is inaccessible.
+    }
+    return undefined;
+};
+const getIgnoredExplicitFileResults = async (cwd, globs, eslint) => {
+    const explicitFilePaths = [...new Set(globs
+            .map(glob => resolveExplicitFilePath(cwd, glob))
+            .filter(filePath => filePath !== undefined))];
+    const results = await Promise.all(explicitFilePaths.map(async (filePath) => await eslint.isPathIgnored(filePath) ? createIgnoredLintResult(filePath) : undefined));
+    return results.filter(result => result !== undefined);
+};
 export class Xo {
     /**
     Static helper to convert an XO config to an ESLint config to be used in `eslint.config.js`.
@@ -113,6 +157,21 @@ export class Xo {
     We use this to also add negative glob patterns in case a user overrides the parserOptions in their XO config.
     */
     tsFilesIgnoresGlob = [];
+    /**
+    Track whether ignores have been added to prevent duplicate ignore configs.
+    */
+    ignoresHandled = false;
+    /**
+    Store per-file configs separately from base config to prevent unbounded array growth.
+    Key: file path, Value: config for that file.
+    This prevents memory bloat in long-running processes (e.g., language servers).
+    */
+    fileConfigs = new Map();
+    /**
+    Track virtual/stdin files that share a single tsconfig.stdin.json.
+    These are handled differently from regular files.
+    */
+    virtualFiles = new Set();
     constructor(_linterOptions, _baseXoConfig = {}) {
         this.linterOptions = _linterOptions;
         this.baseXoConfig = _baseXoConfig;
@@ -120,6 +179,12 @@ export class Xo {
         if (!path.isAbsolute(this.linterOptions.cwd)) {
             this.linterOptions.cwd = path.resolve(process.cwd(), this.linterOptions.cwd);
         }
+        try {
+            this.linterOptions.cwd = syncFs.realpathSync.native(this.linterOptions.cwd);
+        }
+        catch {
+            // Ignore invalid paths here; the caller will handle errors later.
+        }
         const backupCacheLocation = path.join(os.tmpdir(), cacheDirName);
         this.cacheLocation = findCacheDirectory({ name: cacheDirName, cwd: this.linterOptions.cwd }) ?? backupCacheLocation;
     }
@@ -155,7 +220,12 @@ export class Xo {
         if (!this.xoConfig) {
             throw new Error('"Xo.setEslintConfig" failed');
         }
-        this.eslintConfig ??= xoToEslintConfig([...this.xoConfig], { prettierOptions: this.prettierConfig });
+        // Combine base config with per-file configs from Map
+        // Deduplicate configs since multiple files can share the same config object
+        const uniqueFileConfigs = [...new Set(this.fileConfigs.values())];
+        const allConfigs = [...this.xoConfig, ...uniqueFileConfigs];
+        // Always regenerate to support instance reuse with new files
+        this.eslintConfig = xoToEslintConfig(allConfigs, { prettierOptions: this.prettierConfig });
     }
     /**
     Sets the ignores on the XO instance.
@@ -163,7 +233,7 @@ export class Xo {
     @private
     */
     setIgnores() {
-        if (!this.baseXoConfig.ignores) {
+        if (this.ignoresHandled || !this.baseXoConfig.ignores) {
             return;
         }
         let ignores = [];
@@ -180,6 +250,7 @@ export class Xo {
             return;
         }
         this.xoConfig.push({ ignores });
+        this.ignoresHandled = true;
     }
     /**
     Ensures the cache directory exists. This needs to run once before both tsconfig handling and running ESLint occur.
@@ -201,7 +272,7 @@ export class Xo {
         }
     }
     /**
-    Checks every TS file to ensure its included in the tsconfig and any that are not included are added to a generated tsconfig for type aware linting.
+    Checks every TS file to ensure its included in the tsconfig and any that are not included are added to an in-memory TypeScript Program for type aware linting.
 
     @param files - The TypeScript files being linted.
     */
@@ -209,25 +280,25 @@ export class Xo {
         if (!this.linterOptions.ts || !files || files.length === 0) {
             return;
         }
-        const tsFiles = matchFilesForTsConfig(this.linterOptions.cwd, files, this.tsFilesGlob, this.tsFilesIgnoresGlob);
-        if (tsFiles.length === 0) {
+        // Get ALL TypeScript files being linted (both new and previously handled)
+        const allTsFiles = matchFilesForTsConfig(this.linterOptions.cwd, files, this.tsFilesGlob, this.tsFilesIgnoresGlob);
+        if (allTsFiles.length === 0) {
+            this.fileConfigs.clear();
+            if (this.virtualFiles.size > 0) {
+                await this.addVirtualFilesToConfig([]);
+            }
             return;
         }
-        const { fallbackTsConfigPath, unincludedFiles } = await handleTsconfig({
+        const { program, existingFiles, virtualFiles } = handleTsconfig({
+            files: allTsFiles,
             cwd: this.linterOptions.cwd,
-            files: tsFiles,
+            cacheLocation: this.cacheLocation,
         });
-        if (!this.xoConfig || unincludedFiles.length === 0) {
-            return;
+        this.fileConfigs.clear();
+        if (existingFiles.length > 0) {
+            this.addExistingFilesToConfig(existingFiles, program);
         }
-        const config = {};
-        config.files = unincludedFiles.map(file => path.relative(this.linterOptions.cwd, file));
-        config.languageOptions ??= {};
-        config.languageOptions.parserOptions ??= {};
-        config.languageOptions.parserOptions['projectService'] = false;
-        config.languageOptions.parserOptions['project'] = fallbackTsConfigPath;
-        config.languageOptions.parserOptions['tsconfigRootDir'] = this.linterOptions.cwd;
-        this.xoConfig.push(config);
+        await this.addVirtualFilesToConfig(virtualFiles);
     }
     /**
     Initializes the ESLint instance on the XO instance.
@@ -249,9 +320,12 @@ export class Xo {
             warnIgnored: false,
             cache: true,
             cacheLocation: this.cacheLocation,
+            cacheStrategy: 'content',
             fix: this.linterOptions.fix,
         };
-        this.eslint ??= new ESLint(eslintOptions);
+        // Always create new instance to support reuse with updated config
+        // ESLint's file-based cache (cacheLocation) persists across instances
+        this.eslint = new ESLint(eslintOptions);
     }
     /**
     Lints the files on the XO instance.
@@ -264,24 +338,28 @@ export class Xo {
             globs = `**/*.{${allExtensions.join(',')}}`;
         }
         globs = arrify(globs);
-        let files = await globby(globs, {
+        const files = await globby(globs, {
             // Merge in command line ignores
             ignore: [...defaultIgnores, ...arrify(this.baseXoConfig.ignores)],
             onlyFiles: true,
             gitignore: true,
             absolute: true,
+            dot: true,
             cwd: this.linterOptions.cwd,
         });
         await this.initEslint(files);
         if (!this.eslint) {
             throw new Error('Failed to initialize ESLint');
         }
+        const { eslint } = this;
+        const ignoredResults = await getIgnoredExplicitFileResults(this.linterOptions.cwd, globs, eslint);
         if (files.length === 0) {
-            files = '!**/*';
+            return this.processReport(ignoredResults);
         }
-        const results = await this.eslint.lintFiles(files);
-        const rulesMeta = this.eslint.getRulesMetaForResults(results);
-        return this.processReport(results, { rulesMeta });
+        const results = await eslint.lintFiles(files);
+        const rulesMeta = eslint.getRulesMetaForResults(results);
+        // No overlap: `warnIgnored: false` makes ESLint silently drop ignored files from `results`.
+        return this.processReport([...results, ...ignoredResults], { rulesMeta });
     }
     /**
     Lints the text on the XO instance.
@@ -304,6 +382,7 @@ export class Xo {
         if (!this.eslint) {
             throw new Error('Failed to initialize ESLint');
         }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         return this.eslint.calculateConfigForFile(filePath);
     }
     async getFormatter(name) {
@@ -313,6 +392,102 @@ export class Xo {
         }
         return this.eslint.loadFormatter(name);
     }
+    /**
+    Add virtual files to the config with a tsconfig approach.
+    */
+    async addVirtualFilesToConfig(files) {
+        if (!this.xoConfig) {
+            return;
+        }
+        try {
+            const nextVirtualFiles = new Set(files);
+            const tsconfigPath = path.join(this.cacheLocation, 'tsconfig.stdin.json');
+            const configIndex = this.xoConfig.findIndex(configItem => {
+                const { languageOptions } = configItem;
+                const parserOptionsCandidate = languageOptions?.parserOptions;
+                const parserOptions = parserOptionsCandidate;
+                return parserOptions?.project === tsconfigPath;
+            });
+            if (nextVirtualFiles.size > 0) {
+                const filesArray = [...nextVirtualFiles];
+                const relativeFiles = filesArray.map(file => path.relative(this.linterOptions.cwd, file));
+                const tsconfigContent = {
+                    compilerOptions: {
+                        ...tsconfigDefaults.compilerOptions,
+                        module: 'ESNext',
+                        moduleResolution: 'NodeNext',
+                        esModuleInterop: true,
+                        skipLibCheck: true,
+                    },
+                    files: filesArray,
+                };
+                await fs.writeFile(tsconfigPath, JSON.stringify(tsconfigContent, null, 2));
+                if (configIndex === -1) {
+                    const parserOptions = {
+                        projectService: false,
+                        project: tsconfigPath,
+                        tsconfigRootDir: this.linterOptions.cwd,
+                    };
+                    this.xoConfig.push({
+                        files: relativeFiles,
+                        languageOptions: {
+                            parser: typescriptParser,
+                            parserOptions,
+                        },
+                    });
+                }
+                else {
+                    const existingConfig = this.xoConfig[configIndex];
+                    this.xoConfig[configIndex] = {
+                        ...existingConfig,
+                        files: relativeFiles,
+                    };
+                }
+                this.virtualFiles.clear();
+                for (const file of nextVirtualFiles) {
+                    this.virtualFiles.add(file);
+                }
+                return;
+            }
+            if (configIndex >= 0) {
+                this.xoConfig.splice(configIndex, 1);
+            }
+            this.virtualFiles.clear();
+            await fs.rm(tsconfigPath, { force: true });
+        }
+        catch (error) {
+            console.warn('XO: Failed to create tsconfig for virtual files. Type-aware linting will be disabled for these files.', error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+    Add existing files to the config with an in-memory TypeScript Program.
+    */
+    addExistingFilesToConfig(files, program) {
+        if (!this.xoConfig || files.length === 0) {
+            return;
+        }
+        const parserOptions = {
+            project: false,
+            projectService: false,
+        };
+        if (program) {
+            parserOptions.programs = [program];
+        }
+        const config = {
+            files: files.map(file => path.relative(this.linterOptions.cwd, file)),
+            languageOptions: {
+                parser: typescriptParser,
+                parserOptions,
+            },
+        };
+        // IMPORTANT: All files intentionally share the same config object reference for memory efficiency.
+        // This prevents unbounded memory growth in long-running processes (e.g., language servers).
+        // The config is immutable after creation, so sharing is safe.
+        // Deduplication happens in setEslintConfig() via Set to avoid duplicate configs in the final array.
+        for (const file of files) {
+            this.fileConfigs.set(file, config);
+        }
+    }
     processReport(report, { rulesMeta = {} } = {}) {
         if (this.linterOptions.quiet) {
             report = ESLint.getErrorResults(report);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xo",
-	"version": "1.2.3",
+	"version": "2.0.0",
 	"description": "JavaScript/TypeScript linter (ESLint wrapper) with great defaults",
 	"license": "MIT",
 	"repository": "xojs/xo",
@@ -18,7 +18,7 @@
 	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=20.17"
+		"node": ">=20.19"
 	},
 	"scripts": {
 		"build": "npm run clean && tsc",
@@ -65,53 +65,51 @@
 		"typescript"
 	],
 	"dependencies": {
-		"@eslint-community/eslint-plugin-eslint-comments": "^4.5.0",
-		"@sindresorhus/tsconfig": "^7.0.0",
-		"@stylistic/eslint-plugin": "^4.2.0",
-		"@typescript-eslint/parser": "^8.37.0",
+		"@eslint-community/eslint-plugin-eslint-comments": "^4.7.1",
+		"@eslint/compat": "^2.0.2",
+		"@sindresorhus/tsconfig": "^8.1.0",
 		"arrify": "^3.0.0",
 		"cosmiconfig": "^9.0.0",
 		"define-lazy-prop": "^3.0.0",
-		"eslint": "^9.31.0",
-		"eslint-config-prettier": "^10.1.5",
-		"eslint-config-xo-react": "^0.28.0",
-		"eslint-config-xo-typescript": "^7.0.0",
-		"eslint-formatter-pretty": "^6.0.1",
-		"eslint-plugin-ava": "^15.0.1",
+		"eslint": "^10.0.2",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-config-xo-react": "^0.29.0",
+		"eslint-config-xo-typescript": "^9.0.0",
+		"eslint-formatter-pretty": "^7.0.0",
+		"eslint-plugin-ava": "^16.0.0",
 		"eslint-plugin-import-x": "^4.16.1",
-		"eslint-plugin-n": "^17.21.0",
-		"eslint-plugin-no-use-extend-native": "^0.7.2",
-		"eslint-plugin-prettier": "^5.5.1",
-		"eslint-plugin-promise": "^7.2.1",
-		"eslint-plugin-unicorn": "^59.0.1",
+		"eslint-plugin-n": "^17.24.0",
+		"eslint-plugin-prettier": "^5.5.5",
+		"eslint-plugin-unicorn": "^63.0.0",
 		"find-cache-directory": "^6.0.0",
-		"get-stdin": "^9.0.0",
-		"get-tsconfig": "^4.10.1",
-		"globals": "^16.3.0",
-		"globby": "^14.1.0",
-		"meow": "^13.2.0",
+		"get-stdin": "^10.0.0",
+		"get-tsconfig": "^4.13.6",
+		"globals": "^17.3.0",
+		"globby": "^16.1.1",
+		"meow": "^14.1.0",
 		"micromatch": "^4.0.8",
-		"open-editor": "^5.1.0",
+		"open-editor": "^6.0.0",
 		"path-exists": "^5.0.0",
-		"prettier": "^3.6.2",
-		"type-fest": "^4.41.0",
-		"typescript-eslint": "^8.37.0"
+		"prettier": "^3.8.1",
+		"type-fest": "^5.4.3",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.56.1"
 	},
 	"devDependencies": {
-		"@commitlint/cli": "^19.8.1",
-		"@commitlint/config-conventional": "^19.8.1",
-		"@types/eslint": "9.6.1",
-		"@types/micromatch": "^4.0.9",
+		"@commitlint/cli": "^20.4.1",
+		"@commitlint/config-conventional": "^20.4.1",
+		"@types/micromatch": "^4.0.10",
+		"@types/node": "^25.2.1",
 		"@types/prettier": "^3.0.0",
 		"ava": "^6.4.1",
-		"dedent": "^1.6.0",
-		"execa": "^9.5.3",
+		"dedent": "^1.7.1",
+		"execa": "^9.6.1",
 		"husky": "^9.1.7",
-		"lint-staged": "^16.0.0",
-		"np": "^10.2.0",
-		"npm-package-json-lint": "^9.0.0",
+		"lint-staged": "^16.2.7",
+		"np": "^11.0.2",
+		"npm-package-json-lint": "^9.1.0",
 		"npm-package-json-lint-config-default": "^8.0.1",
-		"prettier-plugin-packagejson": "^2.5.18",
+		"prettier-plugin-packagejson": "^3.0.0",
 		"temp-dir": "^3.0.0",
 		"xo": "file:."
 	},
@@ -143,5 +141,10 @@
 			"text",
 			"lcov"
 		]
+	},
+	"xo": {
+		"rules": {
+			"ava/no-ignored-test-files": "off"
+		}
 	}
 }

package/readme.md

@@ -27,7 +27,7 @@ It uses [ESLint](https://eslint.org) underneath, so issues regarding built-in ru
 - No need to specify file paths to lint as it lints all JS/TS files except for [commonly ignored paths](#ignores).
 - [Flat config customization.](#config)
 - [TypeScript supported by default.](#typescript)
-- Includes many useful ESLint plugins, like [`unicorn`](https://github.com/sindresorhus/eslint-plugin-unicorn), [`import`](https://github.com/benmosher/eslint-plugin-import), [`ava`](https://github.com/avajs/eslint-plugin-ava), [`n`](https://github.com/eslint-community/eslint-plugin-n) and more.
+- Includes many useful ESLint plugins, like [`unicorn`](https://github.com/sindresorhus/eslint-plugin-unicorn), [`import-x`](https://github.com/un-ts/eslint-plugin-import-x), [`ava`](https://github.com/avajs/eslint-plugin-ava), [`n`](https://github.com/eslint-community/eslint-plugin-n) and more.
 - Caches results between runs for much better performance.
 - Super simple to add XO to a project with [`$ npm init xo`](https://github.com/xojs/create-xo).
 - Fix many issues automagically with `$ xo --fix`.
@@ -46,7 +46,7 @@ npm install xo --save-dev
 
 *You must install XO locally. You can run it directly with `$ npx xo`.*
 
-*You'll need [eslint-config-xo-vue](https://github.com/ChocPanda/eslint-config-xo-vue#use-with-xo) for specific linting in a Vue app.*
+*For framework-specific linting, see [Astro](#astro), [Svelte](#svelte), and [Vue](#vue).*
 
 ## Usage
 
@@ -136,16 +136,16 @@ export default [...] satisfies import('xo').FlatXoConfig
 
 ### files
 
-Type: `string | string[] | undefined`\
+Type: `string | (string | string[])[]`\
 Default: `**/*.{js,cjs,mjs,jsx,ts,cts,mts,tsx,vue,svelte,astro}`
 
-A glob or array of glob strings which the config object will apply. By default `XO` will apply the configuration to [all files](lib/constants.ts).
+A glob string, array of globs, or ESLint's native format (where nested arrays create AND patterns) indicating which files the config object applies to. By default `XO` will apply the configuration to [all files](lib/constants.ts). This is compatible with ESLint plugin configs, so you can spread them directly into your XO config.
 
 > Tip: If you are adding additional `@typescript-eslint` rules to your config, these rules will apply to JS files as well unless you separate them appropriately with the `files` option. `@typescript-eslint` rules set to `'off'` or `0`, however, will have no effect on JS linting.
 
 ### ignores
 
-Type: `string[]`
+Type: `string | string[]`
 
 Some [paths](lib/constants.ts) are ignored by default, including paths in `.gitignore`. Additional ignores can be added here.
 
@@ -204,6 +204,66 @@ Default: `false`
 
 Adds `eslint-plugin-react`, `eslint-plugin-react-hooks`, and `eslint-config-xo-react` to get all the React best practices applied automatically.
 
+### Astro
+
+To lint [Astro](https://astro.build) files, install [`eslint-plugin-astro`](https://github.com/ota-meshi/eslint-plugin-astro):
+
+```sh
+npm install --save-dev eslint-plugin-astro
+```
+
+Then spread its recommended config in your `xo.config.js`:
+
+```js
+import astroPlugin from 'eslint-plugin-astro';
+
+const xoConfig = [
+	...astroPlugin.configs.recommended,
+];
+
+export default xoConfig;
+```
+
+### Svelte
+
+To lint [Svelte](https://svelte.dev) files, install [`eslint-plugin-svelte`](https://github.com/sveltejs/eslint-plugin-svelte):
+
+```sh
+npm install --save-dev eslint-plugin-svelte
+```
+
+Then spread its recommended config in your `xo.config.js`:
+
+```js
+import sveltePlugin from 'eslint-plugin-svelte';
+
+const xoConfig = [
+	...sveltePlugin.configs.recommended,
+];
+
+export default xoConfig;
+```
+
+### Vue
+
+To lint [Vue](https://vuejs.org) files, install [`eslint-plugin-vue`](https://github.com/vuejs/eslint-plugin-vue):
+
+```sh
+npm install --save-dev eslint-plugin-vue
+```
+
+Then spread its recommended config in your `xo.config.js`:
+
+```js
+import vuePlugin from 'eslint-plugin-vue';
+
+const xoConfig = [
+	...vuePlugin.configs['flat/recommended'],
+];
+
+export default xoConfig;
+```
+
 ## TypeScript
 
 XO will automatically lint TypeScript files (`.ts`, `.mts`, `.cts`, and `.tsx`) with the rules defined in [eslint-config-xo-typescript#use-with-xo](https://github.com/xojs/eslint-config-xo-typescript#use-with-xo).
@@ -306,6 +366,12 @@ Show the world you're using XO → [![XO code style](https://shields.io/badge/co
 [![XO code style](https://shields.io/badge/code_style-5ed9c7?logo=xo&labelColor=gray&logoSize=auto)](https://github.com/xojs/xo)
 ```
 
+Large badge: [![XO code style](https://shields.io/badge/code_style-5ed9c7?style=for-the-badge&logo=xo&labelColor=gray&logoSize=auto)](https://github.com/xojs/xo)
+
+```md
+[![XO code style](https://shields.io/badge/code_style-5ed9c7?style=for-the-badge&logo=xo&labelColor=gray&logoSize=auto)](https://github.com/xojs/xo)
+```
+
 Or [customize the badge](https://github.com/xojs/xo/issues/689#issuecomment-1253127616).
 
 You can also find some nice dynamic XO badges on [badgen.net](https://badgen.net/#xo).