xo 2.0.2 → 3.0.0

package/dist/lib/types.d.ts

@@ -1,6 +1,12 @@
 import type { Simplify } from 'type-fest';
 import { type ESLint, type Rule, type Linter } from 'eslint';
 export type Space = boolean | number | string | undefined;
+export type TypeScriptParserOptions = Linter.ParserOptions & {
+    project?: string | string[] | boolean;
+    projectService?: boolean;
+    tsconfigRootDir?: string;
+    programs?: unknown[];
+};
 export type XoConfigOptions = {
     /**
     Use spaces for indentation.
@@ -19,10 +25,6 @@ export type XoConfigOptions = {
     */
     prettier?: boolean | 'compat';
     /**
-    Add React support.
-    */
-    react?: boolean;
-    /**
     Files to ignore, can be a glob or array of globs.
     */
     ignores?: string | string[];
@@ -49,13 +51,16 @@ export type LinterOptions = {
 
     Ensures that TypeScript files are linted with the type-aware parser even if they are not explicitly included in the tsconfig.
 
-    @private
     */
     ts?: boolean;
     /**
     Custom path to config to use for the linter.
     */
     configPath?: string;
+    /**
+    Path to the ESLint suppressions file. Defaults to `eslint-suppressions.json` in the working directory.
+    */
+    suppressionsLocation?: string;
 };
 export type LintTextOptions = {
     /**

package/dist/lib/utils.d.ts

@@ -1,6 +1,7 @@
 import { type Linter } from 'eslint';
+import { typescriptParser } from 'eslint-config-xo';
 import { type XoConfigItem } from './types.js';
-export declare const typescriptParser: Linter.Parser | undefined;
+export { typescriptParser };
 /**
 Convert a `xo` config item to an ESLint config item.
 
@@ -8,8 +9,8 @@ In a flat structure these config items represent the config object items.
 
 Files and rules will always be defined and all other ESLint config properties are preserved.
 
-@param xoConfig
-@returns eslintConfig
+@param xoConfig - The XO config item to convert.
+@returns The equivalent ESLint config item.
 */
 export declare const xoToEslintConfigItem: (xoConfig: XoConfigItem) => Linter.Config;
 /**
@@ -23,6 +24,12 @@ Function used to match files which should be included in the `tsconfig.json` fil
 */
 export declare const matchFilesForTsConfig: (cwd: string, files: string[] | undefined, globs: string[], ignores: string[]) => string[];
 /**
+Validate an XO config array for legacy ESLint config properties that are not supported in flat config.
+
+@param xoConfig - The flat XO config to validate.
+*/
+export declare const validateXoConfig: (xoConfig: XoConfigItem[]) => void;
+/**
 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.

package/dist/lib/utils.js

@@ -1,16 +1,9 @@
 import path from 'node:path';
 import micromatch from 'micromatch';
 import arrify from 'arrify';
-import configXoTypescript from 'eslint-config-xo-typescript';
+import { typescriptParser } from 'eslint-config-xo';
 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');
-}
+export { typescriptParser }; // eslint-disable-line unicorn/prefer-export-from -- Also used locally
 /**
 Convert a `xo` config item to an ESLint config item.
 
@@ -18,15 +11,15 @@ In a flat structure these config items represent the config object items.
 
 Files and rules will always be defined and all other ESLint config properties are preserved.
 
-@param xoConfig
-@returns eslintConfig
+@param xoConfig - The XO config item to convert.
+@returns The equivalent ESLint config item.
 */
 export const xoToEslintConfigItem = (xoConfig) => {
-    const { files, rules, space, prettier, ignores, semicolon, react, ..._xoConfig } = xoConfig;
+    const { files, rules, space, prettier, ignores, semicolon: hasSemicolon, ..._xoConfig } = xoConfig;
     const eslintConfig = {
         ..._xoConfig,
-        ...(xoConfig.files ? { files: arrify(xoConfig.files) } : {}),
-        ...(xoConfig.rules ? { rules: xoConfig.rules } : {}),
+        ...(xoConfig.files !== undefined && { files: arrify(xoConfig.files) }),
+        ...(xoConfig.rules && { rules: xoConfig.rules }),
     };
     eslintConfig.ignores &&= arrify(xoConfig.ignores);
     return eslintConfig;
@@ -47,6 +40,37 @@ globs.map(glob => path.normalize(glob)), {
     ignore: ignores.map(file => path.normalize(file)),
     cwd,
 }).map(file => path.resolve(cwd, file));
+const legacyPropertyHints = {
+    overrides: 'Use an array of config objects with `files` patterns instead.',
+    extends: 'Spread the config directly into your XO config array.',
+    env: 'Use `languageOptions.globals` instead.',
+    globals: 'Move to `languageOptions.globals`.',
+    parser: 'Move to `languageOptions.parser`.',
+    parserOptions: 'Move to `languageOptions.parserOptions`.',
+    root: 'Not needed in flat config.',
+    ecmaVersion: 'Move to `languageOptions.ecmaVersion`.',
+    sourceType: 'Move to `languageOptions.sourceType`.',
+    noInlineConfig: 'Move to `linterOptions.noInlineConfig`.',
+    reportUnusedDisableDirectives: 'Move to `linterOptions.reportUnusedDisableDirectives`.',
+    ignorePatterns: 'Use `ignores` instead.',
+    react: 'Install `eslint-config-xo-react` and spread it into your XO config instead.',
+};
+/**
+Validate an XO config array for legacy ESLint config properties that are not supported in flat config.
+
+@param xoConfig - The flat XO config to validate.
+*/
+export const validateXoConfig = (xoConfig) => {
+    // Skip the first item (internal base config prepended by XO)
+    for (const config of xoConfig.values().drop(1)) {
+        for (const key of Object.keys(config)) {
+            const hint = legacyPropertyHints[key];
+            if (hint !== undefined) {
+                throw new Error(`Invalid XO config property \`${key}\`. ${hint}`);
+            }
+        }
+    }
+};
 /**
 Once a config is resolved, it is pre-processed to ensure that all properties are set correctly.
 
@@ -57,22 +81,18 @@ This includes ensuring that user-defined properties can override XO defaults, an
 */
 // eslint-disable-next-line complexity
 export const preProcessXoConfig = (xoConfig) => {
+    validateXoConfig(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);
-            continue;
-        }
+    // The first config item is the internal base config; push it through unmodified.
+    const processedConfig = xoConfig[0] ? [{ ...xoConfig[0] }] : [];
+    for (const { ...config } of xoConfig.values().drop(1)) {
+        const { languageOptions } = config;
+        const parserOptions = languageOptions?.['parserOptions'];
         // 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
-            // eslint-disable-next-line @typescript-eslint/dot-notation
-            && !languageOptions?.['parser']
+            && languageOptions?.['parser'] === undefined
             && parserOptions?.project === undefined
             && parserOptions?.programs === undefined
             && !config.plugins?.['@typescript-eslint']) {
@@ -89,7 +109,7 @@ export const preProcessXoConfig = (xoConfig) => {
             });
             if (hasTsRules) {
                 let isAppliedToJsFiles = false;
-                if (config.files) {
+                if (config.files !== undefined) {
                     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);
@@ -106,11 +126,6 @@ export const preProcessXoConfig = (xoConfig) => {
                         ? { ...languageOptions, parser: typescriptParser }
                         : { parser: typescriptParser };
                     config.languageOptions = updatedLanguageOptions;
-                    config.plugins ??= {};
-                    config.plugins = {
-                        ...config.plugins,
-                        ...configXoTypescript[1]?.plugins,
-                    };
                     tsFilesGlob.push(...arrify(config.files ?? allFilesGlob).flat());
                     tsFilesIgnoresGlob.push(...arrify(config.ignores));
                 }

package/dist/lib/xo-to-eslint.d.ts

@@ -1,11 +1,7 @@
 import { type Linter } from 'eslint';
-import { type Options } from 'prettier';
 import { type XoConfigItem } from './types.js';
-export type CreateConfigOptions = {
-    prettierOptions?: Options;
-};
 /**
-Takes a XO flat config and returns an ESlint flat config.
+Takes an XO flat config and returns an ESLint flat config.
 */
-export declare function xoToEslintConfig(flatXoConfig: XoConfigItem[] | undefined, { prettierOptions }?: CreateConfigOptions): Linter.Config[];
+export declare function xoToEslintConfig(flatXoConfig: XoConfigItem[] | undefined): Linter.Config[];
 export default xoToEslintConfig;

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

@@ -1,10 +1,6 @@
-/* eslint-disable complexity */
-import configXoTypescript from 'eslint-config-xo-typescript';
+/* eslint-disable complexity -- Translating every XO config option into ESLint rules is inherently branchy. */
 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 { getPrettierConfig } from 'eslint-config-xo';
 import { config } from './config.js';
 import { xoToEslintConfigItem } from './utils.js';
 /**
@@ -41,9 +37,9 @@ const hoistPlugins = (configs, userPluginOverrides) => {
     ];
 };
 /**
-Takes a XO flat config and returns an ESlint flat config.
+Takes an XO flat config and returns an ESLint flat config.
 */
-export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
+export function xoToEslintConfig(flatXoConfig) {
     const baseConfig = [...config];
     const userPluginOverrides = new Map();
     for (const xoConfigItem of flatXoConfig ?? []) {
@@ -64,12 +60,12 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
             continue;
         }
         /** Special case global ignores */
-        if (xoConfigItem.ignores) {
+        if (xoConfigItem.ignores !== undefined) {
             if (keysOfXoConfig.length === 1) {
                 baseConfig.push({ ignores: arrify(xoConfigItem.ignores) });
                 continue;
             }
-            else if (keysOfXoConfig.length === 2 && xoConfigItem.name) {
+            if (keysOfXoConfig.length === 2 && xoConfigItem.name !== undefined) {
                 baseConfig.push({ name: xoConfigItem.name, ignores: arrify(xoConfigItem.ignores) });
                 continue;
             }
@@ -78,91 +74,49 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         An ESLint config item derived from the XO config item with rules and files initialized.
         */
         const eslintConfigItem = xoToEslintConfigItem(xoConfigItem);
+        const isUsingSpaces = Boolean(xoConfigItem.space);
         if (xoConfigItem.semicolon === false) {
             eslintConfigItem.rules ??= {};
             eslintConfigItem.rules['@stylistic/semi'] = ['error', 'never'];
-            eslintConfigItem.rules['@stylistic/semi-spacing'] = [
+            eslintConfigItem.rules['@stylistic/semi-spacing'] = ['error', { before: false, after: true }];
+            eslintConfigItem.rules['@stylistic/member-delimiter-style'] = [
                 'error',
-                { before: false, after: true },
+                {
+                    multiline: { delimiter: 'none' },
+                    singleline: { delimiter: 'comma', requireLast: false },
+                },
             ];
         }
-        if (xoConfigItem.space) {
+        if (isUsingSpaces) {
             const spaces = typeof xoConfigItem.space === 'number' ? xoConfigItem.space : 2;
             eslintConfigItem.rules ??= {};
-            eslintConfigItem.rules['@stylistic/indent'] = [
-                'error',
-                spaces,
-                // eslint-disable-next-line @typescript-eslint/naming-convention
-                { SwitchCase: 1 },
-            ];
+            eslintConfigItem.rules['@stylistic/indent'] = ['error', spaces, { SwitchCase: 1 }]; // eslint-disable-line @typescript-eslint/naming-convention
             eslintConfigItem.rules['@stylistic/indent-binary-ops'] = ['error', spaces];
         }
         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
-            // TODO: Remove `fixupConfigRules` wrapping when eslint-config-xo-react supports ESLint 10 natively.
-            baseConfig.push({ ...fixupConfigRules(configReact)[0], ...(eslintConfigItem.files ? { files: eslintConfigItem.files } : {}), name: 'xo/react' });
-        }
-        // Prettier should generally be the last config in the array
-        if (xoConfigItem.prettier) {
-            if (xoConfigItem.prettier === 'compat') {
-                baseConfig.push({ ...eslintConfigPrettier, ...(eslintConfigItem.files ? { files: eslintConfigItem.files } : {}) });
-            }
-            else {
-                // Validate that Prettier options match other `xoConfig` options.
-                // 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.`);
-                }
-                if (((xoConfigItem.space ?? typeof xoConfigItem.space === 'number') && prettierOptions.useTabs === true) || (!xoConfigItem.space && prettierOptions.useTabs === false)) {
-                    throw new Error(`The Prettier config \`useTabs\` is ${prettierOptions.useTabs} while Xo \`space\` is ${xoConfigItem.space}, also check your .editorconfig for inconsistencies.`);
-                }
-                if (typeof xoConfigItem.space === 'number' && typeof prettierOptions.tabWidth === 'number' && xoConfigItem.space !== prettierOptions.tabWidth) {
-                    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: fixupPluginRules(pluginPrettier),
-                };
-                const prettierConfig = {
-                    singleQuote: true,
-                    bracketSpacing: false,
-                    bracketSameLine: false,
-                    trailingComma: 'all',
-                    tabWidth: typeof xoConfigItem.space === 'number' ? xoConfigItem.space : 2,
-                    useTabs: !xoConfigItem.space,
-                    semi: xoConfigItem.semicolon,
-                    ...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],
-                    ...eslintConfigPrettier.rules,
-                };
-                eslintConfigItem.rules = rulesWithPrettier;
-            }
+            eslintConfigItem.rules['@stylistic/indent'] = ['error', 'tab', { SwitchCase: 1 }]; // eslint-disable-line @typescript-eslint/naming-convention
+            eslintConfigItem.rules['@stylistic/indent-binary-ops'] = ['error', 'tab'];
         }
-        else if (xoConfigItem.prettier === false) {
+        // Delegate Prettier integration to `eslint-config-xo`. Its config is pushed after `eslintConfigItem` below so it comes last, disabling the conflicting stylistic rules set above.
+        const prettierConfig = getPrettierConfig({
+            prettier: xoConfigItem.prettier,
+            // `Space` allows `string` for legacy reasons, but Prettier only needs `boolean | number`.
+            space: xoConfigItem.space,
+            semicolon: xoConfigItem.semicolon,
+            files: eslintConfigItem.files,
+        });
+        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;
+        if (Object.keys(eslintConfigItem).length > 0) {
+            baseConfig.push(eslintConfigItem);
+        }
+        if (prettierConfig) {
+            baseConfig.push(prettierConfig);
         }
-        baseConfig.push(eslintConfigItem);
     }
     // User plugins should always win, even if XO injects plugins later in the config list.
     return hoistPlugins(baseConfig, userPluginOverrides);

package/dist/lib/xo.d.ts

@@ -1,13 +1,9 @@
 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';
+import { type XoLintResult, type LinterOptions, type LintTextOptions, type XoConfigOptions } from './types.js';
 export declare const ignoredFileWarningMessage = "File ignored because of a matching ignore pattern.";
+export declare const noFilesFoundErrorMessage = "No files matching the pattern were found.";
 export declare class Xo {
-    /**
-    Static helper to convert an XO config to an ESLint config to be used in `eslint.config.js`.
-    */
-    static xoToEslintConfig: typeof xoToEslintConfig;
+    #private;
     /**
     Static helper for backwards compatibility and use in editor extensions and other tools.
     */
@@ -20,90 +16,33 @@ export declare class Xo {
     Write the fixes to disk.
     */
     static outputFixes(results: XoLintResult): Promise<void>;
+    constructor(_linterOptions: LinterOptions, _baseXoConfig?: XoConfigOptions);
     /**
-    Required linter options: `cwd`, `fix`, and `filePath` (in case of `lintText`).
-    */
-    linterOptions: LinterOptions;
-    /**
-    Base XO config options that allow configuration from CLI or other sources. Not to be confused with the `xoConfig` property which is the resolved XO config from the flat config AND base config.
-    */
-    baseXoConfig: XoConfigOptions;
-    /**
-    File path to the ESLint cache.
-    */
-    cacheLocation: string;
-    /**
-    A re-usable ESLint instance configured with options calculated from the XO config.
-    */
-    eslint?: ESLint;
-    /**
-    XO config derived from both the base config and the resolved flat config.
-    */
-    xoConfig?: XoConfigItem[];
-    /**
-    The ESLint config calculated from the resolved XO config.
-    */
-    eslintConfig?: Linter.Config[];
-    /**
-    The flat XO config path, if there is one.
-    */
-    flatConfigPath?: string | undefined;
-    /**
-    If any user configs contain 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.
+    Initializes the ESLint flat config on the XO instance.
     */
-    tsFilesIgnoresGlob: string[];
+    private prepareEslintConfig;
+    private discoverFiles;
     /**
-    Track whether ignores have been added to prevent duplicate ignore configs.
+    Add virtual files to the config with a tsconfig approach.
     */
-    private ignoresHandled;
+    private addVirtualFilesToConfig;
     /**
-    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).
+    Add existing files to the config with an in-memory TypeScript Program.
     */
-    private readonly fileConfigs;
+    private addExistingFilesToConfig;
+    private processReport;
+    private getReportStatistics;
     /**
-    Track virtual/stdin files that share a single tsconfig.stdin.json.
-    These are handled differently from regular files.
+    Throws if a suppressions location was provided but the file does not exist.
     */
-    private readonly virtualFiles;
-    constructor(_linterOptions: LinterOptions, _baseXoConfig?: XoConfigOptions);
+    private assertSuppressionsFileExists;
     /**
     Sets the XO config on the XO instance.
-
-    @private
     */
     setXoConfig(): Promise<void>;
-    /**
-    Sets the ESLint config on the XO instance.
-
-    @private
-    */
-    setEslintConfig(): void;
-    /**
-    Sets the ignores on the XO instance.
-
-    @private
-    */
-    setIgnores(): void;
+    setEslintConfig(cliIgnores?: string[], stripDefaultIgnores?: boolean): void;
     /**
     Ensures the cache directory exists. This needs to run once before both tsconfig handling and running ESLint occur.
-
-    @private
     */
     ensureCacheDirectory(): Promise<void>;
     /**
@@ -115,7 +54,11 @@ export declare class Xo {
     /**
     Initializes the ESLint instance on the XO instance.
     */
-    initEslint(files?: string[]): Promise<void>;
+    initEslint(files?: string[], cliIgnores?: string[], stripDefaultIgnores?: boolean): Promise<void>;
+    /**
+    Create an ESLint flat config for editor integrations using the same XO pipeline as the CLI.
+    */
+    getProjectEslintConfig(): Promise<Linter.Config[]>;
     /**
     Lints the files on the XO instance.
 
@@ -129,15 +72,5 @@ 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;
 }
 export default Xo;