xo 1.1.0 → 1.2.0

package/dist/cli.d.ts

@@ -10,8 +10,9 @@ declare const cli: import("meow").Result<{
     space: {
         type: "string";
     };
-    config: {
+    configPath: {
         type: "string";
+        aliases: string[];
     };
     quiet: {
         type: "boolean";

package/dist/cli.js

@@ -21,7 +21,7 @@ const cli = meow(`
     --config          Path to a XO configuration file
     --semicolon       Use semicolons [Default: true]
     --react           Include React specific parsing and xo-react linting rules [Default: false]
-    --prettier        Format with prettier or turn off prettier conflicted rules when set to 'compat' [Default: false]
+    --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
@@ -52,8 +52,9 @@ const cli = meow(`
         space: {
             type: 'string',
         },
-        config: {
+        configPath: {
             type: 'string',
+            aliases: ['config'],
         },
         quiet: {
             type: 'boolean',
@@ -108,6 +109,7 @@ const linterOptions = {
     cwd: (cliOptions.cwd && path.resolve(cliOptions.cwd)) ?? process.cwd(),
     quiet: cliOptions.quiet,
     ts: true,
+    configPath: cliOptions.configPath,
 };
 // Make data types for `options.space` match those of the API
 if (typeof cliOptions.space === 'string') {
@@ -196,7 +198,8 @@ if (typeof cliOptions.printConfig === 'string') {
         console.error('The `--print-config` flag must be used with exactly one filename');
         process.exit(1);
     }
-    const config = await new Xo(linterOptions, baseXoConfigOptions).calculateConfigForFile(cliOptions.printConfig);
+    const absoluteFilePath = path.resolve(cliOptions.cwd, cliOptions.printConfig);
+    const config = await new Xo(linterOptions, baseXoConfigOptions).calculateConfigForFile(absoluteFilePath);
     console.log(JSON.stringify(config, undefined, '\t'));
 }
 else {

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

@@ -25,9 +25,6 @@ export async function handleTsconfig({ cwd, files }) {
         unincludedFiles.push(filePath);
     }
     const fallbackTsConfigPath = path.join(cwd, 'node_modules', '.cache', cacheDirName, 'tsconfig.xo.json');
-    delete tsConfig.include;
-    delete tsConfig.exclude;
-    delete tsConfig.files;
     tsConfig.files = unincludedFiles;
     if (unincludedFiles.length > 0) {
         try {

package/dist/lib/resolve-config.js

@@ -32,7 +32,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 flatConfigExplorer.search(searchPath) ?? {};
+        let { config: flatOptions = [], filepath: flatConfigPath = '', } = await (options.configPath
+            ? flatConfigExplorer.load(path.resolve(options.cwd, options.configPath))
+            : flatConfigExplorer.search(searchPath)) ?? {};
         flatOptions = arrify(flatOptions);
         return {
             flatOptions,

package/dist/lib/types.d.ts

@@ -52,6 +52,10 @@ export type LinterOptions = {
     @private
     */
     ts?: boolean;
+    /**
+    Custom path to config to use for the linter.
+    */
+    configPath?: string;
 };
 export type LintTextOptions = {
     /**

package/dist/lib/utils.d.ts

@@ -1,5 +1,5 @@
-import { type SetRequired } from 'type-fest';
 import { type Linter } from 'eslint';
+import { type SetRequired } from 'type-fest';
 import { type XoConfigItem } from './types.js';
 /**
 Convert a `xo` config item to an ESLint config item.
@@ -12,3 +12,26 @@ Files and rules will always be defined and all other ESLint config properties ar
 @returns eslintConfig
 */
 export declare const xoToEslintConfigItem: (xoConfig: XoConfigItem) => SetRequired<Linter.Config, "rules" | "files">;
+/**
+Function used to match files which should be included in the `tsconfig.json` files.
+
+@param cwd - The current working directory to resolve relative filepaths.
+@param files - The _absolute_ file paths to match against the globs.
+@param globs - The globs to match the files against.
+@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[];
+/**
+Once a config is resolved, it is pre-processed to ensure that all properties are set correctly.
+
+This includes ensuring that user-defined properties can override XO defaults, and that files are parsed correctly and performantly based on the users XO config.
+
+@param xoConfig - The flat XO config to pre-process.
+@returns The pre-processed flat XO config.
+*/
+export declare const preProcessXoConfig: (xoConfig: XoConfigItem[]) => {
+    config: XoConfigItem[];
+    tsFilesGlob: string[];
+    tsFilesIgnoresGlob: string[];
+};

package/dist/lib/utils.js

@@ -1,5 +1,8 @@
+import path from 'node:path';
+import micromatch from 'micromatch';
 import arrify from 'arrify';
-import { allFilesGlob } from './constants.js';
+import configXoTypescript from 'eslint-config-xo-typescript';
+import { allFilesGlob, jsExtensions, jsFilesGlob, } from './constants.js';
 /**
 Convert a `xo` config item to an ESLint config item.
 
@@ -20,4 +23,98 @@ export const xoToEslintConfigItem = (xoConfig) => {
     eslintConfig.ignores &&= arrify(xoConfig.ignores);
     return eslintConfig;
 };
+/**
+Function used to match files which should be included in the `tsconfig.json` files.
+
+@param cwd - The current working directory to resolve relative filepaths.
+@param files - The _absolute_ file paths to match against the globs.
+@param globs - The globs to match the files against.
+@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))), 
+// https://github.com/micromatch/micromatch/issues/217
+globs.map(glob => path.normalize(glob)), {
+    dot: true,
+    ignore: ignores.map(file => path.normalize(file)),
+    cwd,
+}).map(file => path.resolve(cwd, file));
+/**
+Once a config is resolved, it is pre-processed to ensure that all properties are set correctly.
+
+This includes ensuring that user-defined properties can override XO defaults, and that files are parsed correctly and performantly based on the users XO config.
+
+@param xoConfig - The flat XO config to pre-process.
+@returns The pre-processed flat XO config.
+*/
+export const preProcessXoConfig = (xoConfig) => {
+    const tsFilesGlob = [];
+    const tsFilesIgnoresGlob = [];
+    const processedConfig = [];
+    for (const [idx, { ...config }] of xoConfig.entries()) {
+        // We can skip the first config  item, as it is the base config item.
+        if (idx === 0) {
+            processedConfig.push(config);
+            continue;
+        }
+        // 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']
+            && !config.plugins?.['@typescript-eslint']) {
+            const hasTsRules = Object.entries(config.rules).some(rulePair => {
+                // If its not a @typescript-eslint rule, we don't care
+                if (!rulePair[0].startsWith('@typescript-eslint/')) {
+                    return false;
+                }
+                if (Array.isArray(rulePair[1])) {
+                    return rulePair[1]?.[0] !== 'off' && rulePair[1]?.[0] !== 0;
+                }
+                return rulePair[1] !== 'off'
+                    && rulePair[1] !== 0;
+            });
+            if (hasTsRules) {
+                let isAppliedToJsFiles = false;
+                if (config.files) {
+                    const normalizedFiles = arrify(config.files).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
+                    // If not, check that the file paths match a js extension
+                    isAppliedToJsFiles = micromatch.some(jsExtensions.map(ext => `test.${ext}`), globs, { dot: true })
+                        || micromatch.some(normalizedFiles, jsFilesGlob, { dot: true });
+                }
+                else if (config.files === undefined) {
+                    isAppliedToJsFiles = true;
+                }
+                if (isAppliedToJsFiles) {
+                    config.languageOptions ??= {};
+                    config.plugins ??= {};
+                    config.plugins = {
+                        ...config.plugins,
+                        ...configXoTypescript[1]?.plugins,
+                    };
+                    config.languageOptions.parser = configXoTypescript[1]?.languageOptions?.parser;
+                    tsFilesGlob.push(...arrify(config.files ?? allFilesGlob));
+                    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) {
+            // The glob itself should NOT be negated
+            tsFilesIgnoresGlob.push(...arrify(config.files ?? allFilesGlob));
+        }
+        processedConfig.push(config);
+    }
+    return {
+        config: processedConfig,
+        tsFilesGlob,
+        tsFilesIgnoresGlob,
+    };
+};
 //# sourceMappingURL=utils.js.map

package/dist/lib/xo.d.ts

@@ -48,13 +48,23 @@ export declare class Xo {
     */
     flatConfigPath?: string | undefined;
     /**
-    If any user configs container Prettier, we will need to fetch the Prettier config.
+    If any user configs contains Prettier, we will need to fetch the Prettier config.
     */
     prettier?: boolean;
     /**
     The Prettier config if it exists and is needed.
     */
     prettierConfig?: prettier.Options;
+    /**
+    The glob pattern for TypeScript files, for which we will handle TS files and tsconfig.
+
+    We expand this based on the XO config and the files glob patterns.
+    */
+    tsFilesGlob: string[];
+    /**
+    We use this to also add negative glob patterns in case a user overrides the parserOptions in their XO config.
+    */
+    tsFilesIgnoresGlob: string[];
     constructor(_linterOptions: LinterOptions, _baseXoConfig?: XoConfigOptions);
     /**
     Sets the XO config on the XO instance.

package/dist/lib/xo.js

@@ -6,13 +6,12 @@ import findCacheDirectory from 'find-cache-directory';
 import { globby } from 'globby';
 import arrify from 'arrify';
 import defineLazyProperty from 'define-lazy-prop';
-import micromatch from 'micromatch';
 import prettier from 'prettier';
-import { defaultIgnores, cacheDirName, allExtensions, tsFilesGlob, allFilesGlob, } from './constants.js';
+import { defaultIgnores, cacheDirName, allExtensions, tsFilesGlob, } from './constants.js';
 import { xoToEslintConfig } from './xo-to-eslint.js';
 import resolveXoConfig from './resolve-config.js';
 import { handleTsconfig } from './handle-ts-files.js';
-// Import {handleTsconfig} from './handle-ts-files-typescript.js';
+import { matchFilesForTsConfig, preProcessXoConfig } from './utils.js';
 export class Xo {
     /**
     Static helper to convert an XO config to an ESLint config to be used in `eslint.config.js`.
@@ -28,6 +27,7 @@ export class Xo {
             filePath: options.filePath,
             quiet: options.quiet,
             ts: options.ts ?? true,
+            configPath: options.configPath,
         }, {
             react: options.react,
             space: options.space,
@@ -50,6 +50,7 @@ export class Xo {
             filePath: options.filePath,
             quiet: options.quiet,
             ts: options.ts,
+            configPath: options.configPath,
         }, {
             react: options.react,
             space: options.space,
@@ -94,13 +95,23 @@ export class Xo {
     */
     flatConfigPath;
     /**
-    If any user configs container Prettier, we will need to fetch the Prettier config.
+    If any user configs contains Prettier, we will need to fetch the Prettier config.
     */
     prettier;
     /**
     The Prettier config if it exists and is needed.
     */
     prettierConfig;
+    /**
+    The glob pattern for TypeScript files, for which we will handle TS files and tsconfig.
+
+    We expand this based on the XO config and the files glob patterns.
+    */
+    tsFilesGlob = [tsFilesGlob];
+    /**
+    We use this to also add negative glob patterns in case a user overrides the parserOptions in their XO config.
+    */
+    tsFilesIgnoresGlob = [];
     constructor(_linterOptions, _baseXoConfig = {}) {
         this.linterOptions = _linterOptions;
         this.baseXoConfig = _baseXoConfig;
@@ -123,53 +134,13 @@ export class Xo {
         const { flatOptions, flatConfigPath } = await resolveXoConfig({
             ...this.linterOptions,
         });
-        this.xoConfig = [
+        const { config, tsFilesGlob, tsFilesIgnoresGlob } = preProcessXoConfig([
             this.baseXoConfig,
             ...flatOptions,
-        ];
-        // Split off the TS rules in a special case, so that you won't get errors
-        // for JS files when the TS rules are not in the config.
-        this.xoConfig = this.xoConfig.flatMap(config => {
-            // If the user does not specify files, then we can assume they want everything to work correctly and
-            // for rules to apply to all files. However, TS rules will error with JS files, so we need to split them off.
-            // if the user supplies files, then we cannot make the same assumption, so we will not split them off.
-            if (config.files) {
-                return config;
-            }
-            const ruleEntries = Object.entries(config.rules ?? {});
-            const otherRules = [];
-            const tsRules = [];
-            for (const [rule, ruleValue] of ruleEntries) {
-                if (!rule || !ruleValue) {
-                    continue;
-                }
-                if (rule.startsWith('@typescript-eslint')) {
-                    tsRules.push([rule, ruleValue]);
-                }
-                else {
-                    otherRules.push([rule, ruleValue]);
-                }
-            }
-            // If no TS rules, return the config as is
-            if (tsRules.length === 0) {
-                return config;
-            }
-            // If there are TS rules, we need to split them off into a new config
-            const tsConfig = {
-                ...config,
-                rules: Object.fromEntries(tsRules),
-            };
-            // Apply TS rules to all files
-            tsConfig.files = [tsFilesGlob];
-            const otherConfig = {
-                ...config,
-                // Set the other rules to the original config
-                rules: Object.fromEntries(otherRules),
-            };
-            // These rules should still apply to all files
-            otherConfig.files = [allFilesGlob];
-            return [tsConfig, otherConfig];
-        });
+        ]);
+        this.xoConfig = config;
+        this.tsFilesGlob.push(...tsFilesGlob);
+        this.tsFilesIgnoresGlob.push(...tsFilesIgnoresGlob);
         this.prettier = this.xoConfig.some(config => config.prettier);
         this.prettierConfig = await prettier.resolveConfig(flatConfigPath, { editorconfig: true }) ?? {};
         this.flatConfigPath = flatConfigPath;
@@ -218,7 +189,7 @@ export class Xo {
         if (!this.linterOptions.ts || !files || files.length === 0) {
             return;
         }
-        const tsFiles = files.filter(file => micromatch.isMatch(file, tsFilesGlob, { dot: true }));
+        const tsFiles = matchFilesForTsConfig(this.linterOptions.cwd, files, this.tsFilesGlob, this.tsFilesIgnoresGlob);
         if (tsFiles.length === 0) {
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xo",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "JavaScript/TypeScript linter (ESLint wrapper) with great defaults",
 	"license": "MIT",
 	"repository": "xojs/xo",
@@ -68,34 +68,34 @@
 		"@eslint-community/eslint-plugin-eslint-comments": "^4.5.0",
 		"@sindresorhus/tsconfig": "^7.0.0",
 		"@stylistic/eslint-plugin": "^4.2.0",
-		"@typescript-eslint/parser": "^8.32.1",
+		"@typescript-eslint/parser": "^8.37.0",
 		"arrify": "^3.0.0",
 		"cosmiconfig": "^9.0.0",
 		"define-lazy-prop": "^3.0.0",
-		"eslint": "^9.27.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-plugin-import-x": "^4.12.2",
-		"eslint-plugin-n": "^17.18.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.4.0",
+		"eslint-plugin-prettier": "^5.5.1",
 		"eslint-plugin-promise": "^7.2.1",
 		"eslint-plugin-unicorn": "^59.0.1",
 		"find-cache-directory": "^6.0.0",
 		"get-stdin": "^9.0.0",
 		"get-tsconfig": "^4.10.1",
-		"globals": "^16.1.0",
+		"globals": "^16.3.0",
 		"globby": "^14.1.0",
 		"meow": "^13.2.0",
 		"micromatch": "^4.0.8",
 		"open-editor": "^5.1.0",
 		"path-exists": "^5.0.0",
-		"prettier": "^3.5.3",
+		"prettier": "^3.6.2",
 		"type-fest": "^4.41.0",
-		"typescript-eslint": "^8.32.1"
+		"typescript-eslint": "^8.37.0"
 	},
 	"devDependencies": {
 		"@commitlint/cli": "^19.8.1",
@@ -103,15 +103,15 @@
 		"@types/eslint": "9.6.1",
 		"@types/micromatch": "^4.0.9",
 		"@types/prettier": "^3.0.0",
-		"ava": "^6.3.0",
+		"ava": "^6.4.1",
 		"dedent": "^1.6.0",
 		"execa": "^9.5.3",
 		"husky": "^9.1.7",
 		"lint-staged": "^16.0.0",
 		"np": "^10.2.0",
-		"npm-package-json-lint": "^8.0.0",
-		"npm-package-json-lint-config-default": "^7.0.1",
-		"prettier-plugin-packagejson": "^2.5.14",
+		"npm-package-json-lint": "^9.0.0",
+		"npm-package-json-lint-config-default": "^8.0.1",
+		"prettier-plugin-packagejson": "^2.5.18",
 		"temp-dir": "^3.0.0",
 		"xo": "file:."
 	},
@@ -133,7 +133,8 @@
 				".history/**/*",
 				"node_modules",
 				"package.json",
-				"xo.config.*"
+				"xo.config.*",
+				"**/*.ts"
 			]
 		}
 	},

package/readme.md

@@ -34,7 +34,7 @@ It uses [ESLint](https://eslint.org) underneath, so issues regarding built-in ru
 - Open all files with errors at the correct line in your editor with `$ xo --open`.
 - Specify [indent](#space) and [semicolon](#semicolon) preferences easily without messing with the rule config.
 - Optionally use the [Prettier](https://github.com/prettier/prettier) code style or turn off all Prettier rules with the `compat` option.
-- Optionally use `eslint-config-xo-react` for easy jsx and react linting with zero config.
+- Optionally use `eslint-config-xo-react` for easy JSX and React linting with zero config.
 - Optionally use with ESLint [directly](#usage-as-an-eslint-configuration)
 - Great [editor plugins](#editor-plugins).
 
@@ -63,7 +63,7 @@ $ xo --help
 		--config          Path to a XO configuration file
 		--semicolon       Use semicolons [Default: true]
 		--react           Include React specific parsing and xo-react linting rules [Default: false]
-		--prettier        Format with prettier or turn off prettier conflicted rules when set to 'compat' [Default: false]
+		--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
@@ -108,7 +108,7 @@ Simply run `$ npm init xo` (with any options) to add XO to create an `xo.config.
 
 ## Config
 
-You can configure XO options by creating an `xo.config.js` or an `xo.config.ts` file in the root directory of your project. XO supports all js/ts file extensions (js,cjs,mjs,ts,cts,mts) automatically. A XO config is an extension of ESLint's Flat Config. Like ESLint, an XO config exports an array of XO config objects. XO config objects extend [ESLint Configuration Objects](https://eslint.org/docs/latest/use/configure/configuration-files#configuration-objects). This means all the available configuration params for ESLint also work for `XO`. However, `XO` enhances and adds extra params to the configuration objects to make them easier to work with.
+You can configure XO options by creating an `xo.config.js` or an `xo.config.ts` file in the root directory of your project, or you can add an `xo` field to your `package.json`. XO supports all js/ts file extensions (js,cjs,mjs,ts,cts,mts) automatically. A XO config is an extension of ESLint's Flat Config. Like ESLint, an XO config exports an array of XO config objects. XO config objects extend [ESLint Configuration Objects](https://eslint.org/docs/latest/use/configure/configuration-files#configuration-objects). This means all the available configuration params for ESLint also work for `XO`. However, `XO` enhances and adds extra params to the configuration objects to make them easier to work with.
 
 ### Config types
 
@@ -124,12 +124,16 @@ const xoConfig = [...]
 
 `xo.config.ts`
 
-```js
+```ts
 import {type FlatXoConfig} from 'xo';
 
 const xoConfig: FlatXoConfig = [...]
 ```
 
+```ts
+export default [...] satisfies import('xo').FlatXoConfig
+```
+
 ### files
 
 Type: `string | string[] | undefined`\
@@ -137,11 +141,15 @@ Default: `**/*.{js,cjs,mjs,jsx,ts,cts,mts,tsx}`
 
 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).
 
+> 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[]`
 
-Some [paths](lib/constants.ts) are ignored by default, including paths in `.gitignore`. Additional ignores can be added here. For global ignores, keep `ignores` as the only key in the config item.
+Some [paths](lib/constants.ts) are ignored by default, including paths in `.gitignore`. Additional ignores can be added here.
+
+> Tip: For *global* ignores, keep `ignores` as the only key in the config item. You can optionally set a `name` property. Adding more properties will cause ignores to be scoped down to your files selection, which may have unexpected effects.
 
 ### space
 
@@ -202,15 +210,17 @@ XO will automatically lint TypeScript files (`.ts`, `.mts`, `.cts`, and `.tsx`)
 
 XO will handle the [@typescript-eslint/parser `project` option](https://typescript-eslint.io/packages/parser/#project) automatically even if you don't have a `tsconfig.json` in your project.
 
+You can opt out of XO's automatic tsconfig handling by specifying your own `languageOptions.parserOptions.project`, `languageOptions.parserOptions.projectService`, or `languageOptions.parserOptions.tsconfigRootDir`. Files in a config with these properties will be excluded from automatic tsconfig handling.
+
 ## Usage as an ESLint Configuration
 
 With the introduction of the ESLint flat config, many of the original goals of `xo` were brought into the ESLint core, and shareable configs with plugins became possible. Although we highly recommend the use of the `xo` cli, we understand that some teams need to rely on ESLint directly.
 
 For these purposes, you can still get most of the features of `xo` by using our ESLint configuration helpers.
 
-### `xoToEslintConfig`
+### xoToEslintConfig
 
-The `xoToEslintConfig` function is designed for use in an `eslint.config.js` file. It is NOT for use in an `xo.config.js` file. This function takes a `FlatXoConfig` and outputs an ESLint config object. This function will neither be able to automatically handle TS integration for you nor automatic Prettier integration. You are responsible for configuring your other tools appropriately. The `xo` cli, will however, handle all of these details for you.
+The `xoToEslintConfig` function is designed for use in an `eslint.config.js` file. It is NOT for use in an `xo.config.js` file. This function takes a `FlatXoConfig` and outputs an ESLint config object. This function will neither be able to automatically handle TS integration for you nor automatic Prettier integration. You are responsible for configuring your other tools appropriately. The `xo` cli, will, however, handle all of these details for you.
 
 `eslint.config.js`