XO

https://github.com/xojs/xo
Admin
XO is an opinionated yet configurable JavaScript/TypeScript linter (ESLint wrapper) that enforces...
Tokens:35,529
Snippets:220
Trust Score:7.5
License:MIT
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install XO with npm

Source: https://github.com/xojs/xo/blob/main/readme.md

Install XO as a dev dependency. XO must be installed locally; you can run it directly with `$ npx xo`.

```sh
npm install xo --save-dev
```

--------------------------------

### calculateConfigForFile example

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Example of using calculateConfigForFile to get the merged flat config for a file and print it as JSON.

```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd()});
const config = await xo.calculateConfigForFile('src/index.ts');
console.log(JSON.stringify(config, null, '\t'));
```

--------------------------------

### XO flat config examples (JS, TS, shareable)

Source: https://github.com/xojs/xo/blob/main/_autodocs/configuration.md

Provides three configuration examples: a JavaScript config with ignores and a test file rule, a TypeScript config with type validation, and a shareable config using a spread.

```js
/** @type {import('xo').FlatXoConfig} */
const xoConfig = [
	// Global ignores: `ignores` must be the only key (+ optional `name`)
	{
		ignores: ['dist/**', 'coverage/**', '!dist/src/index.js'],
	},
	{
		files: ['**/*.test.ts'],
		rules: {
			'@typescript-eslint/no-non-null-assertion': 'off',
		},
		languageOptions: {
			parserOptions: {
				project: './tsconfig.test.json',
			},
		},
	},
];

export default xoConfig;
```

```ts
import {type FlatXoConfig} from 'xo';

const xoConfig: FlatXoConfig = [...];
export default xoConfig;
// or
export default [...] satisfies import('xo').FlatXoConfig;
```

```js
import xoReact from 'eslint-config-xo-react';
export default [...xoReact()];
```

--------------------------------

### FlatXoConfig type and usage example

Source: https://github.com/xojs/xo/blob/main/_autodocs/types.md

Defines the FlatXoConfig type and shows a usage example. The type accepts a single config item or an array of items, normalized with arrify in resolveXoConfig. The example config uses ignores and files with rules.

```ts
export type FlatXoConfig = XoConfigItem | XoConfigItem[];
```

```ts
import type {FlatXoConfig} from 'xo';

const xoConfig: FlatXoConfig = [
	{
		ignores: ['dist/**', 'vendor/**'],
	},
	{
		files: ['**/*.test.ts'],
		rules: {
			'unicorn/no-fn-reference-in-iterator': 'off',
		},
	},
];

export default xoConfig;
```

--------------------------------

### Install and configure eslint-plugin-astro for Astro linting

Source: https://github.com/xojs/xo/blob/main/readme.md

Install eslint-plugin-astro and spread its recommended config in xo.config.js to lint Astro files.

```sh
npm install --save-dev eslint-plugin-astro
```

```js
import astroPlugin from 'eslint-plugin-astro';

const xoConfig = [
	...astroPlugin.configs.recommended,
];

export default xoConfig;
```

--------------------------------

### XO CLI help output

Source: https://github.com/xojs/xo/blob/main/readme.md

Shows the XO CLI help output, including usage, options, examples, and tips. Options include --fix, --space, --prettier, --print-config, --stdin, and more. The examples demonstrate common invocations like `xo index.js` and `xo --print-config=index.js`.

```console
$ xo --help

	Usage
		$ xo [<file|glob> ...]

	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
		--semicolon               Use semicolons [Default: true]
		--prettier                Format with prettier or turn off Prettier-conflicted rules when set to 'compat' [Default: false]
		--print-config            Print the effective ESLint config for the given file
		--version                 Print XO version
		--open                    Open files with issues in your editor
		--quiet                   Show only errors and no warnings
		--max-warnings            Number of warnings to trigger nonzero exit code [Default: -1]
		--stdin                   Validate/fix code from stdin
		--stdin-filename          Specify a filename for the --stdin option
		--ignore                  Ignore pattern globs, can be set multiple times
		--suppressions-location   Path to a custom ESLint suppressions file
		--cwd=<dir>               Working directory for files [Default: process.cwd()]

	Examples
		$ xo
		$ xo index.js
		$ xo *.js !foo.js
		$ xo --space
		$ xo --print-config=index.js
		$ echo 'const x=true' | xo --stdin --fix

	Tips
		- Add XO to your project with `npm init xo`.
		- Put options in xo.config.js instead of using flags so other tools can read it.
```

--------------------------------

### Install and configure eslint-plugin-vue for Vue linting

Source: https://github.com/xojs/xo/blob/main/readme.md

Install eslint-plugin-vue and spread its recommended config in xo.config.js to lint Vue files.

```sh
npm install --save-dev eslint-plugin-vue
```

```js
import vuePlugin from 'eslint-plugin-vue';

const xoConfig = [
	...vuePlugin.configs['flat/recommended'],
];

export default xoConfig;
```

--------------------------------

### Install and configure eslint-plugin-svelte for Svelte linting

Source: https://github.com/xojs/xo/blob/main/readme.md

Install eslint-plugin-svelte and spread its recommended config in xo.config.js to lint Svelte files.

```sh
npm install --save-dev eslint-plugin-svelte
```

```js
import sveltePlugin from 'eslint-plugin-svelte';

const xoConfig = [
	...sveltePlugin.configs.recommended,
];

export default xoConfig;
```

--------------------------------

### Usage example for importing constants

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/constants.md

Shows how to import `allFilesGlob`, `tsFilesGlob`, and `jsFilesGlob` from `xo` and use them with the `Xo` class to lint files.

```ts
import Xo, {allFilesGlob, tsFilesGlob, jsFilesGlob} from 'xo';

console.log(allFilesGlob); // **/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts,vue,svelte,astro}

const xo = new Xo({cwd: process.cwd()});
const report = await xo.lintFiles(tsFilesGlob); // lint only TypeScript files
```

--------------------------------

### Basic lintText example

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Basic usage of lintText with a code string and options including filePath and warnIgnored.

```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd()});
const report = await xo.lintText('const x = 1', {
	filePath: 'index.js',
	warnIgnored: true,
});
```

--------------------------------

### Basic Xo construction example

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Basic construction of an Xo instance with linter options (`cwd`, `ts`, `fix`) and base config options (`space`, `semicolon`, `prettier`). Relative `cwd` values are resolved against `process.cwd()` and realpath-normalized; invalid paths are silently left for later error handling.

```ts
import Xo from 'xo';

const xo = new Xo(
	{
		cwd: process.cwd(),
		ts: true,
		fix: false,
	},
	{
		space: true,
		semicolon: true,
		prettier: 'compat',
	},
);
```

--------------------------------

### Xo.lintFiles usage example

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Example of using `Xo.lintFiles` to lint files matching a glob pattern. The `cwd` option is required. If the report has errors, `Xo.outputFixes` is called to write fixes.

```ts
import Xo from 'xo';

const report = await Xo.lintFiles('src/**/*.{js,ts}', {
	cwd: '/path/to/project',
});
if (report.errorCount > 0) {
	await Xo.outputFixes(report);
}
```

--------------------------------

### Xo.lintText usage example

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Example of using `Xo.lintText` to lint a code string. The `cwd` and `filePath` options are required. The result exposes `errorCount` and `warningCount`; errors are caught and logged.

```ts
import Xo from 'xo';

try {
	const report = await Xo.lintText('const answer = 42', {
		cwd: process.cwd(),
		filePath: 'index.js',
	});
	console.log(report.errorCount, report.warningCount);
} catch (error) {
	console.error('Linting failed:', error);
}
```

--------------------------------

### lintText fixable autofix example

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Example of using lintText with fix: true to autofix code. The fixed code is in result.output and written with outputFixes.

```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd(), fix: true});
// 'lintText' returns the fixed code in result.output; write it with outputFixes
const report = await xo.lintText('const   x=1', {filePath: 'index.js'});
await Xo.outputFixes(report);
const [result] = report.results;
console.log(result.output); // fixed source text
```

--------------------------------

### Xo.outputFixes usage example

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Example of using `Xo.outputFixes` with an instance's lint results. The instance is created with `fix: true`, then `lintFiles()` is called and the report is passed to `outputFixes`. The console logs the total fixable issues.

```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd(), fix: true});
const report = await xo.lintFiles();
await Xo.outputFixes(report);
console.log(`Fixed ${report.fixableErrorCount + report.fixableWarningCount} fixable issues`);
```

--------------------------------

### Basic lintFiles example

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Basic usage of lintFiles with a glob pattern and negation. Logs error, warning, and fixable error counts.

```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd()});
const report = await xo.lintFiles(['src/**/*.ts', '!src/generated/**']);
console.log(report.errorCount, report.warningCount, report.fixableErrorCount);
```

--------------------------------

### Install and configure eslint-config-xo-react for React linting

Source: https://github.com/xojs/xo/blob/main/readme.md

Install eslint-config-xo-react and spread it in xo.config.js to lint React files. Until eslint-plugin-react supports ESLint 10 natively, you may need to wrap the config with fixupConfigRules from @eslint/compat.

```sh
npm install --save-dev eslint-config-xo-react
```

```js
import xoReact from 'eslint-config-xo-react';

const xoConfig = [
	...xoReact(),
];

export default xoConfig;
```

--------------------------------

### XoLintResult type and usage example

Source: https://github.com/xojs/xo/blob/main/_autodocs/types.md

Defines the XoLintResult type and shows a usage example. The type is returned by lintFiles/lintText and includes counts, per-file results, and rulesMeta. The example creates an Xo instance, lints files, and logs error/warning counts.

```ts
export type XoLintResult = {
	errorCount: number;
	warningCount: number;
	fixableErrorCount: number;
	fixableWarningCount: number;
	results: ESLint.LintResult[];
	rulesMeta: Record<string, Rule.RuleMetaData>;
};
```

```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd()});
const report: Awaited<ReturnType<typeof xo.lintFiles>> = await xo.lintFiles();

if (report.errorCount > 0) {
	console.error(`${report.errorCount} errors, ${report.warningCount} warnings`);
}
```

--------------------------------

### lintFiles error handling example

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Error handling example for lintFiles. Catches the noFilesFoundErrorMessage and logs a custom message, otherwise rethrows.

```ts
import Xo, {noFilesFoundErrorMessage} from 'xo';

const xo = new Xo({cwd: process.cwd()});
try {
	const report = await xo.lintFiles(['src/index.js']);
	console.log(report.results);
} catch (error) {
	if (error instanceof Error && error.message === noFilesFoundErrorMessage) {
		console.error('No matching files were found.');
	} else {
		throw error;
	}
}
```

--------------------------------

### getProjectEslintConfig: signature and usage

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

The first block shows the method signature for `getProjectEslintConfig`, which returns the full ESLint flat config without running a lint. The second block demonstrates usage: create an Xo instance with TypeScript enabled, get the config, and print it or feed it into ESLint's overrideConfig.

```ts
public async getProjectEslintConfig(): Promise<Linter.Config[]>
```

```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd(), ts: true});
const eslintConfig = await xo.getProjectEslintConfig();
// feed eslintConfig into ESLint's overrideConfig, or print it
console.log(eslintConfig);
```

--------------------------------

### Include ignored files with negative globs in ignores option

Source: https://github.com/xojs/xo/blob/main/readme.md

Add negative globs to the `ignores` option to include files that XO ignores by default. This example includes the `vendor/**` directory.

```javascript
const xoConfig = [{ignores: ['!vendor/**']}];

export default xoConfig;
```

--------------------------------

### getFormatter: signature and usage

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

The first block shows the method signature for `getFormatter`, which returns a promise of an ESLint formatter. The second block demonstrates usage: create an Xo instance, lint files, get the 'json' formatter, and format the report results.

```ts
async getFormatter(name: string)
```

```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd()});
const report = await xo.lintFiles();
const formatter = await xo.getFormatter('json');
console.log(await formatter.format(report.results));
```

--------------------------------

### initEslint(files?, cliIgnores?, shouldStripDefaultIgnores?)

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Builds the ESLint config via `prepareEslintConfig` and constructs the ESLint instance. A new instance is always created to support reuse with updated config; the file-based cache persists across instances.

```APIDOC
## initEslint(files?, cliIgnores?, shouldStripDefaultIgnores?)

### Description
Builds the ESLint config via `prepareEslintConfig` and constructs the ESLint instance. A new instance is always created to support reuse with updated config; the file-based cache persists across instances.

### Method
public async initEslint(files?: string[], cliIgnores: string[] = arrify(this.#baseXoConfig.ignores), shouldStripDefaultIgnores = false): Promise<void>

### Parameters
- `files` (string[]) - Optional - Files used for TS-inclusion handling and config preparation.
- `cliIgnores` (string[]) - Optional - Ignore patterns appended as a final global ignore config item. Defaults to `arrify(this.#baseXoConfig.ignores)`.
- `shouldStripDefaultIgnores` (boolean) - Optional - When true, strips XO's built-in default-ignore config items from the final config (used by `lintFiles`). Defaults to `false`.

### Request Example
```ts
// Example usage (not provided in source, but method is called internally)
```

### Response
Returns a Promise that resolves to void.

```

--------------------------------

### initEslint: signature and ESLint instance construction

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

The first block shows the method signature for `initEslint`, which builds the ESLint config and constructs the ESLint instance. The second block shows the ESLint options object and instance creation; a new instance is always created to support reuse with updated config, and the file-based cache persists across instances.

```ts
public async initEslint(files?: string[], cliIgnores: string[] = arrify(this.#baseXoConfig.ignores), shouldStripDefaultIgnores = false)
```

```ts
const eslintOptions: ESLint.Options = {
	cwd: this.#linterOptions.cwd,
	overrideConfig: this.#eslintConfig,
	overrideConfigFile: true,
	globInputPaths: false,
	warnIgnored: false,
	cache: true,
	cacheLocation: this.#cacheLocation,
	cacheStrategy: 'content',
	fix: this.#linterOptions.fix,
	applySuppressions: true,
	suppressionsLocation: this.#linterOptions.suppressionsLocation,
};

this.#eslint = new ESLint(eslintOptions);
```

--------------------------------

### new Xo(_linterOptions, _baseXoConfig)

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Constructor for the Xo class, accepting linter options and base configuration.

```APIDOC
## Constructor

```ts
constructor(_linterOptions: LinterOptions, _baseXoConfig: XoConfigOptions = {})
```

### Description
Creates a new Xo instance with linter behavior and base configuration options.

### Parameters
- `_linterOptions` (LinterOptions) - Required - Linter behavior: `cwd` (required), `fix`, `filePath`, `quiet`, `ts`, `configPath`, `suppressionsLocation`.
- `_baseXoConfig` (XoConfigOptions) - Optional, default `{}` - Base style/ignore options: `space`, `semicolon`, `prettier`, `ignores`. Treated as the first config item and merged with the resolved flat config.

### Behavior
- Relative `cwd` values are resolved against `process.cwd()` and then realpath-normalized (`syncFs.realpathSync.native`); invalid paths are silently left for later error handling.
- The ESLint cache location is `findCacheDirectory({name: 'xo-linter', cwd})` with a fallback to `path.join(os.tmpdir(), 'xo-linter')`. The generated-tsconfig directory is the cache directory if it lives inside `cwd`, otherwise `cwd/node_modules/.cache/xo-linter`.

### Example — basic construction

```ts
import Xo from 'xo';

const xo = new Xo(
	{
		cwd: process.cwd(),
		ts: true,
		fix: false,
	},
	{
		space: true,
		semicolon: true,
		prettier: 'compat',
	},
);
```
```

--------------------------------

### Xo constructor signature

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Constructor signature for the Xo class. `_linterOptions` is required and includes `cwd` (required), `fix`, `filePath`, `quiet`, `ts`, `configPath`, and `suppressionsLocation`. `_baseXoConfig` is optional and defaults to `{}`; it holds base style/ignore options (`space`, `semicolon`, `prettier`, `ignores`) and is treated as the first config item merged with the resolved flat config.

```ts
constructor(_linterOptions: LinterOptions, _baseXoConfig: XoConfigOptions = {})
```

--------------------------------

### Xo.lintText static method signature

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Static method signature for `Xo.lintText`. It lints a string of code and returns a `Promise<XoLintResult>`. `options` must include `cwd` and `filePath`; `ts` defaults to `true` here (`options.ts ?? true`). Provided for backwards compatibility and editor extensions.

```ts
static async lintText(code: string, options: LintTextOptions & LinterOptions & XoConfigOptions)
```

--------------------------------

### getProjectEslintConfig()

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Discovers files with `defaultFilesGlob` and returns the full ESLint flat config (`Linter.Config[]`) produced by `prepareEslintConfig`, without running a lint. This is the pipeline used by the ESLint adapter for editor integrations.

```APIDOC
## getProjectEslintConfig()

### Description
Discovers files with `defaultFilesGlob` and returns the full ESLint flat config (`Linter.Config[]`) produced by `prepareEslintConfig`, without running a lint. This is the pipeline used by the ESLint adapter for editor integrations.

### Method
public async getProjectEslintConfig(): Promise<Linter.Config[]>

### Parameters
None.

### Request Example
```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd(), ts: true});
const eslintConfig = await xo.getProjectEslintConfig();
// feed eslintConfig into ESLint's overrideConfig, or print it
console.log(eslintConfig);
```

### Response
Returns a Promise that resolves to an array of ESLint flat config objects (`Linter.Config[]`).

```

--------------------------------

### XO config pipeline diagram

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/modules.md

ASCII diagram of the XO config pipeline: resolveXoConfig → preProcessXoConfig → setEslintConfig/setXoConfig → xoToEslintConfig → new ESLint. Shows the data flow and intermediate types for each step.

```text
resolveXoConfig (cosmiconfig + jiti)
        │  {flatOptions: XoConfigItem[], flatConfigPath: string}
        ▼
preProcessXoConfig ([baseXoConfig, ...flatOptions])
        │  {config: XoConfigItem[], tsFilesGlob: string[], tsFilesIgnoresGlob: string[]}
        ▼
setEslintConfig / setXoConfig (Xo instance)
        │
        ▼
xoToEslintConfig (XoConfigItem[] → Linter.Config[])
        │
        ▼
new ESLint({overrideConfig, cache, ...})
```

--------------------------------

### Xo.outputFixes

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Static method to write fixes from lint results to disk.

```APIDOC
## Xo.outputFixes

```ts
static async outputFixes(results: XoLintResult)
```

### Description
Writes the `output` field of each lint result back to disk. Works with results from any `Xo` method (instance or static).

### Parameters
- `results` (XoLintResult) - Required - Lint result to write fixes for.

### Returns
`Promise<void>`

### Example

```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd(), fix: true});
const report = await xo.lintFiles();
await Xo.outputFixes(report);
console.log(`Fixed ${report.fixableErrorCount + report.fixableWarningCount} fixable issues`);
```
```

--------------------------------

### calculateConfigForFile method signature

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Signature of the calculateConfigForFile method. It accepts a file path and returns a promise of Linter.Config.

```ts
async calculateConfigForFile(filePath: string): Promise<Linter.Config>
```

--------------------------------

### Xo.lintFiles

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Static method to lint files matching glob patterns.

```APIDOC
## Xo.lintFiles

```ts
static async lintFiles(globs: string | undefined, options: LinterOptions & XoConfigOptions)
```

### Description
Lints files matching the given glob patterns and returns a lint report.

### Parameters
- `globs` (string | undefined) - Required - Glob(s) to lint; `undefined` uses XO's default file glob.
- `options` (LinterOptions & XoConfigOptions) - Required - Same option union as `Xo.lintText`; note `ts` is passed through as-is (no `true` default).

### Returns
`Promise<XoLintResult>`

### Example

```ts
import Xo from 'xo';

const report = await Xo.lintFiles('src/**/*.{js,ts}', {
	cwd: '/path/to/project',
});
if (report.errorCount > 0) {
	await Xo.outputFixes(report);
}
```
```

--------------------------------

### lintFiles

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Discovers files matching glob patterns, runs ESLint, and returns a lint report.

```APIDOC
## `lintFiles`

### Description
Discovers files matching the given glob patterns, runs ESLint on them, and returns a lint report. This method handles file discovery, ESLint initialization, and error reporting for missing files or suppressions.

### Method
`lintFiles`

### Signature
```ts
async lintFiles(globs?: string | string[]): Promise<XoLintResult>
```

### Parameters
- `globs` (string | string[]) - Optional - Glob pattern(s) passed to `globby`. Defaults to `defaultFilesGlob` (`**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts,vue,svelte,astro,html,md,json,css}`).

### Throws
- `Error` (`noFilesFoundErrorMessage`) - When explicit literal file path globs match no files and no files were ignored.
- `Error & {exitCode: 2}` - When the suppressions file is missing.
- `Error` (`'Failed to initialize ESLint'`, `'"Xo.initEslint" failed'`, `'"Xo.prepareEslintConfig" failed'`) - Internal invariant failure (config not prepared).

### Example
```ts
import Xo from 'xo';

const xo = new Xo({cwd: process.cwd()});
const report = await xo.lintFiles(['src/**/*.ts', '!src/generated/**']);
console.log(report.errorCount, report.warningCount, report.fixableErrorCount);
```

### Example (error handling)
```ts
import Xo, {noFilesFoundErrorMessage} from 'xo';

const xo = new Xo({cwd: process.cwd()});
try {
	const report = await xo.lintFiles(['src/index.js']);
	console.log(report.results);
} catch (error) {
	if (error instanceof Error && error.message === noFilesFoundErrorMessage) {
		console.error('No matching files were found.');
	} else {
		throw error;
	}
}
```
```

--------------------------------

### Xo.lintFiles static method signature

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Static method signature for `Xo.lintFiles`. It lints files matching the given globs (or XO's default glob if `undefined`) and returns a `Promise<XoLintResult>`. Unlike `Xo.lintText`, `ts` is passed through as-is with no `true` default.

```ts
static async lintFiles(globs: string | undefined, options: LinterOptions & XoConfigOptions)
```

--------------------------------

### Module graph of xo package

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/index.md

Shows the module graph of the xo package, listing public and internal exports for each file. Use it to understand the package structure and which symbols are publicly re-exported.

```text
index.ts  (package root entry)
├── lib/constants.ts        → allFilesGlob, jsFilesGlob, tsFilesGlob (public re-export)
│                              + internal: defaultFilesGlob, codeFilesGlob, moduleName,
│                                tsconfigDefaults, cacheDirName, tsExtensions, jsExtensions,
│                                frameworkExtensions, allExtensions, defaultIgnores
├── lib/types.ts            → FlatXoConfig, XoConfigItem (public); other types internal
└── lib/xo.ts               → Xo class (default + named), ignoredFileWarningMessage,
                               noFilesFoundErrorMessage
    ├── lib/types.js
    ├── lib/constants.js
    ├── lib/xo-to-eslint.js → xoToEslintConfig (internal)
    ├── lib/resolve-config.js → resolveXoConfig (internal)
    ├── lib/handle-ts-files.js → handleTsconfig (internal)
    └── lib/utils.js        → matchFilesForTsConfig, preProcessXoConfig, typescriptParser,
                               xoToEslintConfigItem, validateXoConfig (internal)

lib/eslint-adapter.ts       → default export: Linter.Config[] (xo/eslint-adapter subpath)
lib/open-report.ts          → default export openReport (internal, used by CLI --open)
lib/config.ts               → config: Linter.Config[] (internal)
cli.ts                      → bin: xo CLI (meow-based, source cli.ts)
```

--------------------------------

### xoToEslintConfig

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/modules.md

Documentation for the xoToEslintConfig function, which converts a resolved XO flat config into a pure ESLint flat config.

```APIDOC
## `xoToEslintConfig`

### Description
Takes the resolved XO flat config and returns a pure ESLint flat config. It collects global style options, builds the base config, appends user config items, and hoists plugins into a single entry.

### Signature
```ts
export function xoToEslintConfig(flatXoConfig: XoConfigItem[] | undefined): Linter.Config[]
```

### Parameters
- **flatXoConfig** (`XoConfigItem[] | undefined`) - The resolved XO flat config items.

### Returns
- **Linter.Config[]** - The pure ESLint flat config.

### Behavior
1. `getGlobalOptions(xoConfig)` collects `space`/`semicolon`/`prettier` across config items. Throws `TypeError('XO style options only support global config items. Use ESLint rules for file-scoped overrides.')` when a config item has both scoped keys (`files`, `basePath`, `ignores`) and style options (`space`, `semicolon`, `prettier`).
2. Builds the base config from `eslintConfigXo(globalOptions)`; if a `xo/prettier` or `xo/prettier-compat` entry exists, its `files` restriction is deleted so XO's global Prettier option applies to every language config.
3. Each user config item is appended: global-`ignores`-only items (optionally with `name`) become standalone `{ignores}` entries; otherwise items are converted with `xoToEslintConfigItem` and appended (empty items dropped).
4. `hoistPlugins` merges all `plugins` from every config into a single `{name: 'xo/plugins', plugins}` entry at the front — ESLint's flat config rejects duplicate plugin names — with user-provided plugins taking precedence over XO-injected ones.
```

--------------------------------

### Xo.lintText

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/xo.md

Static method to lint a string of code.

```APIDOC
## Xo.lintText

```ts
static async lintText(code: string, options: LintTextOptions & LinterOptions & XoConfigOptions)
```

### Description
Lints a string of source code and returns a lint report. Provided for backwards compatibility and editor extensions.

### Parameters
- `code` (string) - Required - Source code to lint.
- `options` (LintTextOptions & LinterOptions & XoConfigOptions) - Required - Union of all option groups; `cwd` and `filePath` are required. `ts` defaults to `true` here (`options.ts ?? true`).

### Returns
`Promise<XoLintResult>`

### Example

```ts
import Xo from 'xo';

try {
	const report = await Xo.lintText('const answer = 42', {
		cwd: process.cwd(),
		filePath: 'index.js',
	});
	console.log(report.errorCount, report.warningCount);
} catch (error) {
	console.error('Linting failed:', error);
}
```
```

--------------------------------

### Generate eslint-suppressions.json with ESLint

Source: https://github.com/xojs/xo/blob/main/readme.md

Run ESLint with `--suppress-all` to generate the `eslint-suppressions.json` file. Requires a temporary `eslint.config.js` using `xo/eslint-adapter`.

```shell
npx eslint --suppress-all
```

--------------------------------

### Root entry point exports (index.ts)

Source: https://github.com/xojs/xo/blob/main/_autodocs/api-reference/index.md

Shows the public exports from the root entry point of the xo package. It re-exports glob constants, two types, and the default Xo class along with all named exports from lib/xo.js.

```typescript
export {
	allFilesGlob,
	jsFilesGlob,
	tsFilesGlob,
} from './lib/constants.js';

export {
	type FlatXoConfig,
	type XoConfigItem,
} from './lib/types.js';

export {default} from './lib/xo.js';
export * from './lib/xo.js';

```

--------------------------------

### LintTextOptions type definition

Source: https://github.com/xojs/xo/blob/main/_autodocs/types.md

Options for the Xo.lintText static and instance methods. filePath is required and used for config matching and TypeScript parsing; warnIgnored optionally produces a synthetic warning result with ignoredFileWarningMessage when the file is ignored.

```typescript
export type LintTextOptions = {
	filePath: string;
	warnIgnored?: boolean;
};
```
Tokens:
Raw