xo 1.2.3 → 2.0.1

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.1",
 	"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",
@@ -33,6 +33,8 @@
 	"files": [
 		"dist/lib/*.js",
 		"dist/lib/*.d.ts",
+		"dist/lib/rules/*.js",
+		"dist/lib/rules/*.d.ts",
 		"dist/*.js",
 		"dist/*.d.ts"
 	],
@@ -65,53 +67,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": "^10.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",
+		"ava": "^7.0.0",
+		"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.3.4",
+		"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 +143,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
 
@@ -58,6 +58,7 @@ $ xo --help
 
 	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
@@ -136,16 +137,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 +205,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 +367,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).