xo 2.0.2 → 3.0.0

package/dist/lib/xo.js

@@ -6,15 +6,18 @@ import process from 'node:process';
 import { ESLint } from 'eslint';
 import findCacheDirectory from 'find-cache-directory';
 import { globby, isDynamicPattern } from 'globby';
+import micromatch from 'micromatch';
 import arrify from 'arrify';
 import defineLazyProperty from 'define-lazy-prop';
-import prettier from 'prettier';
 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, typescriptParser, } from './utils.js';
 export const ignoredFileWarningMessage = 'File ignored because of a matching ignore pattern.';
+export const noFilesFoundErrorMessage = 'No files matching the pattern were found.';
+const suppressionsFileMissingErrorMessage = 'The suppressions file does not exist. Please run the command with `--suppress-all` or `--suppress-rule` to create it.';
+const createErrorWithExitCode = (message, exitCode) => Object.assign(new Error(message), { exitCode });
 const createIgnoredLintResult = (filePath) => ({
     filePath,
     messages: [
@@ -34,6 +37,24 @@ const createIgnoredLintResult = (filePath) => ({
     fixableWarningCount: 0,
     usedDeprecatedRules: [],
 });
+const normalizeGlobPath = (filePath) => filePath.split(path.sep).join('/');
+const pathMatchesPattern = (filePath, pattern) => micromatch.isMatch(normalizeGlobPath(filePath), normalizeGlobPath(pattern), { dot: true });
+const isIgnoredByPatterns = (filePath, patterns) => {
+    let isIgnored = false;
+    for (const pattern of patterns) {
+        if (pattern.startsWith('!')) {
+            if (pathMatchesPattern(filePath, pattern.slice(1))) {
+                isIgnored = false;
+            }
+            continue;
+        }
+        if (pathMatchesPattern(filePath, pattern)) {
+            isIgnored = true;
+        }
+    }
+    return isIgnored;
+};
+const isIgnoredFile = (cwd, filePath, patterns) => isIgnoredByPatterns(path.relative(cwd, filePath), patterns);
 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.
@@ -50,18 +71,110 @@ const resolveExplicitFilePath = (cwd, glob) => {
     }
     return undefined;
 };
-const getIgnoredExplicitFileResults = async (cwd, globs, eslint) => {
+const getIgnoredExplicitFileResults = async (cwd, globs, eslint, discoveryIgnores = []) => {
     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));
+    const results = await Promise.all(explicitFilePaths.map(async (filePath) => {
+        if (isIgnoredFile(cwd, filePath, discoveryIgnores)) {
+            return createIgnoredLintResult(filePath);
+        }
+        return await eslint.isPathIgnored(filePath) ? createIgnoredLintResult(filePath) : undefined;
+    }));
     return results.filter(result => result !== undefined);
 };
+const isGlobalIgnoreConfig = (config) => {
+    const keys = Object.keys(config);
+    return config.ignores !== undefined && (keys.length === 1 || (keys.length === 2 && config.name !== undefined));
+};
+const expandIgnoreNegationForEslint = (pattern) => {
+    const negatedPattern = pattern.slice(1);
+    const { base, isGlob } = micromatch.scan(negatedPattern, { parts: true });
+    const parentPath = isGlob ? base : path.posix.dirname(negatedPattern);
+    if (parentPath === '' || parentPath === '.') {
+        return [pattern];
+    }
+    const expandedPatterns = parentPath.split('/').map((_, index, segments) => `!${segments.slice(0, index + 1).join('/')}`);
+    expandedPatterns.push(pattern);
+    return expandedPatterns;
+};
+const expandIgnoreNegationsForEslint = (patterns) => patterns.flatMap(pattern => pattern.startsWith('!') ? expandIgnoreNegationForEslint(pattern) : [pattern]);
+const expandGlobalIgnoreConfigForEslint = (config) => {
+    if (!isGlobalIgnoreConfig(config)) {
+        return config;
+    }
+    return {
+        ...config,
+        ignores: expandIgnoreNegationsForEslint(arrify(config.ignores)),
+    };
+};
+const stripDefaultIgnoreConfigs = (configs) => configs.map(configItem => {
+    const { ignores } = configItem;
+    const isDefaultIgnoreConfig = ignores !== undefined && ignores.length > 0 && ignores.every(pattern => defaultIgnores.includes(pattern));
+    if (!isDefaultIgnoreConfig) {
+        return configItem;
+    }
+    const { ignores: _ignored, ...configWithoutIgnores } = configItem;
+    return configWithoutIgnores;
+});
+const defaultIgnoreOverlapsReopenedPattern = (defaultIgnore, pattern) => {
+    const { base, isGlob } = micromatch.scan(pattern, { parts: true });
+    const patternDirname = path.posix.dirname(pattern);
+    const reopenedBase = isGlob ? base : (patternDirname === '' ? pattern : patternDirname);
+    const { base: defaultBase, isGlob: isDefaultGlob } = micromatch.scan(defaultIgnore, { parts: true });
+    const ignoreBase = isDefaultGlob ? defaultBase : defaultIgnore;
+    return micromatch.isMatch(pattern, defaultIgnore, { dot: true })
+        || micromatch.isMatch(defaultIgnore, pattern, { dot: true })
+        || ignoreBase === ''
+        || reopenedBase === ''
+        || ignoreBase.startsWith(`${reopenedBase}/`)
+        || reopenedBase.startsWith(`${ignoreBase}/`);
+};
+const getReopenedDefaultPatterns = (patterns) => patterns
+    .filter(pattern => pattern.startsWith('!'))
+    .map(pattern => pattern.slice(1))
+    .filter(pattern => defaultIgnores.some(defaultIgnore => defaultIgnoreOverlapsReopenedPattern(defaultIgnore, pattern)));
+/**
+XO only compensates for negations that reopen its built-in default ignores.
+User-provided positive ignores are still used only for pruning.
+The flow is:
+1. discover with `defaultIgnores + positive global ignores`
+2. if a negation reopens a built-in default ignore, run one extra pass with only that default ignore relaxed
+3. apply the real global ignore order in XO: default ignores, then config ignores, then CLI ignores
+4. let ESLint make the final ignore decision
+
+This keeps the common "lint files XO ignores by default" behavior without trying to fully reimplement ESLint's ignore engine during discovery.
+*/
+const discoverLintFiles = async ({ cwd, globs, positiveGlobalIgnores, discoveryIgnores, reopenedDefaultPatterns }) => {
+    const discoveredFiles = await globby(globs, {
+        ignore: [...defaultIgnores, ...positiveGlobalIgnores],
+        onlyFiles: true,
+        gitignore: true,
+        globalGitignore: true,
+        absolute: true,
+        dot: true,
+        cwd,
+    });
+    const effectiveIgnores = [...defaultIgnores, ...discoveryIgnores];
+    if (reopenedDefaultPatterns.length === 0) {
+        return discoveredFiles.filter(filePath => !isIgnoredFile(cwd, filePath, effectiveIgnores));
+    }
+    const reopenedFiles = await globby(globs, {
+        ignore: [
+            ...positiveGlobalIgnores,
+            ...defaultIgnores.filter(defaultIgnore => reopenedDefaultPatterns.every(pattern => !defaultIgnoreOverlapsReopenedPattern(defaultIgnore, pattern))),
+        ],
+        onlyFiles: true,
+        gitignore: true,
+        globalGitignore: true,
+        absolute: true,
+        dot: true,
+        cwd,
+    });
+    return [...new Set([...discoveredFiles, ...reopenedFiles])]
+        .filter(filePath => !isIgnoredFile(cwd, filePath, effectiveIgnores));
+};
 export class Xo {
-    /**
-    Static helper to convert an XO config to an ESLint config to be used in `eslint.config.js`.
-    */
-    static xoToEslintConfig = xoToEslintConfig;
     /**
     Static helper for backwards compatibility and use in editor extensions and other tools.
     */
@@ -73,8 +186,8 @@ export class Xo {
             quiet: options.quiet,
             ts: options.ts ?? true,
             configPath: options.configPath,
+            suppressionsLocation: options.suppressionsLocation,
         }, {
-            react: options.react,
             space: options.space,
             semicolon: options.semicolon,
             prettier: options.prettier,
@@ -96,8 +209,8 @@ export class Xo {
             quiet: options.quiet,
             ts: options.ts,
             configPath: options.configPath,
+            suppressionsLocation: options.suppressionsLocation,
         }, {
-            react: options.react,
             space: options.space,
             semicolon: options.semicolon,
             prettier: options.prettier,
@@ -114,303 +227,116 @@ export class Xo {
     /**
     Required linter options: `cwd`, `fix`, and `filePath` (in case of `lintText`).
     */
-    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;
+    #linterOptions;
     /**
     File path to the ESLint cache.
     */
-    cacheLocation;
-    /**
-    A re-usable ESLint instance configured with options calculated from the XO config.
-    */
-    eslint;
+    #cacheLocation;
     /**
     XO config derived from both the base config and the resolved flat config.
     */
-    xoConfig;
+    #xoConfig;
     /**
-    The ESLint config calculated from the resolved XO config.
-    */
-    eslintConfig;
-    /**
-    The flat XO config path, if there is one.
+    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.
     */
-    flatConfigPath;
+    #baseXoConfig;
     /**
-    If any user configs contain Prettier, we will need to fetch the Prettier config.
+    A re-usable ESLint instance configured with options calculated from the XO config.
     */
-    prettier;
+    #eslint;
     /**
-    The Prettier config if it exists and is needed.
+    The ESLint config calculated from the resolved XO config.
     */
-    prettierConfig;
+    #eslintConfig;
     /**
     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];
+    #tsFilesGlob = [tsFilesGlob];
     /**
     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;
+    #tsFilesIgnoresGlob = [];
     /**
     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();
+    #fileConfigs = new Map();
     /**
     Track virtual/stdin files that share a single tsconfig.stdin.json.
     These are handled differently from regular files.
     */
-    virtualFiles = new Set();
+    #virtualFiles = new Set();
     constructor(_linterOptions, _baseXoConfig = {}) {
-        this.linterOptions = _linterOptions;
-        this.baseXoConfig = _baseXoConfig;
+        this.#linterOptions = _linterOptions;
+        this.#baseXoConfig = _baseXoConfig;
         // Fix relative cwd paths
-        if (!path.isAbsolute(this.linterOptions.cwd)) {
-            this.linterOptions.cwd = path.resolve(process.cwd(), this.linterOptions.cwd);
+        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);
+            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;
-    }
-    /**
-    Sets the XO config on the XO instance.
-
-    @private
-    */
-    async setXoConfig() {
-        if (this.xoConfig) {
-            return;
-        }
-        const { flatOptions, flatConfigPath } = await resolveXoConfig({
-            ...this.linterOptions,
-        });
-        const { config, tsFilesGlob, tsFilesIgnoresGlob } = preProcessXoConfig([
-            this.baseXoConfig,
-            ...flatOptions,
-        ]);
-        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;
-    }
-    /**
-    Sets the ESLint config on the XO instance.
-
-    @private
-    */
-    setEslintConfig() {
-        if (!this.xoConfig) {
-            throw new Error('"Xo.setEslintConfig" failed');
-        }
-        // 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.
-
-    @private
-    */
-    setIgnores() {
-        if (this.ignoresHandled || !this.baseXoConfig.ignores) {
-            return;
-        }
-        let ignores = [];
-        if (typeof this.baseXoConfig.ignores === 'string') {
-            ignores = arrify(this.baseXoConfig.ignores);
-        }
-        else if (Array.isArray(this.baseXoConfig.ignores)) {
-            ignores = this.baseXoConfig.ignores;
-        }
-        if (!this.xoConfig) {
-            throw new Error('"Xo.setIgnores" failed');
-        }
-        if (ignores.length === 0) {
-            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.
-
-    @private
-    */
-    async ensureCacheDirectory() {
-        try {
-            const cacheStats = await fs.stat(this.cacheLocation);
-            // If file, re-create as directory
-            if (cacheStats.isFile()) {
-                await fs.rm(this.cacheLocation, { recursive: true, force: true });
-                await fs.mkdir(this.cacheLocation, { recursive: true });
-            }
-        }
-        catch {
-            // If not exists, create the directory
-            await fs.mkdir(this.cacheLocation, { recursive: true });
-        }
-    }
-    /**
-    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.
-    */
-    async handleUnincludedTsFiles(files) {
-        if (!this.linterOptions.ts || !files || files.length === 0) {
-            return;
-        }
-        // 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 { program, existingFiles, virtualFiles } = handleTsconfig({
-            files: allTsFiles,
-            cwd: this.linterOptions.cwd,
-            cacheLocation: this.cacheLocation,
-        });
-        this.fileConfigs.clear();
-        if (existingFiles.length > 0) {
-            this.addExistingFilesToConfig(existingFiles, program);
-        }
-        await this.addVirtualFilesToConfig(virtualFiles);
+        this.#cacheLocation = findCacheDirectory({ name: cacheDirName, cwd: this.#linterOptions.cwd }) ?? backupCacheLocation;
     }
     /**
-    Initializes the ESLint instance on the XO instance.
+    Initializes the ESLint flat config on the XO instance.
     */
-    async initEslint(files) {
+    async prepareEslintConfig(files, cliIgnores = arrify(this.#baseXoConfig.ignores), stripDefaultIgnores = false) {
         await this.setXoConfig();
-        this.setIgnores();
         await this.ensureCacheDirectory();
         await this.handleUnincludedTsFiles(files);
-        this.setEslintConfig();
-        if (!this.xoConfig) {
-            throw new Error('"Xo.initEslint" failed');
-        }
-        const eslintOptions = {
-            cwd: this.linterOptions.cwd,
-            overrideConfig: this.eslintConfig,
-            overrideConfigFile: true,
-            globInputPaths: false,
-            warnIgnored: false,
-            cache: true,
-            cacheLocation: this.cacheLocation,
-            cacheStrategy: 'content',
-            fix: this.linterOptions.fix,
-        };
-        // 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.
-
-    @param globs - Glob pattern to pass to `globby`.
-    @throws Error
-    */
-    async lintFiles(globs) {
-        if (!globs || (Array.isArray(globs) && globs.length === 0)) {
-            globs = `**/*.{${allExtensions.join(',')}}`;
-        }
-        globs = arrify(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');
+        this.setEslintConfig(cliIgnores, stripDefaultIgnores);
+        if (!this.#eslintConfig) {
+            throw new Error('"Xo.prepareEslintConfig" failed');
         }
-        const { eslint } = this;
-        const ignoredResults = await getIgnoredExplicitFileResults(this.linterOptions.cwd, globs, eslint);
-        if (files.length === 0) {
-            return this.processReport(ignoredResults);
-        }
-        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 });
+        return this.#eslintConfig;
     }
-    /**
-    Lints the text on the XO instance.
-    */
-    async lintText(code, lintTextOptions) {
-        const { filePath, warnIgnored } = lintTextOptions;
-        await this.initEslint([filePath]);
-        if (!this.eslint) {
-            throw new Error('Failed to initialize ESLint');
-        }
-        const results = await this.eslint?.lintText(code, {
-            filePath,
-            warnIgnored,
+    async discoverFiles(globs) {
+        await this.setXoConfig();
+        const cliIgnores = arrify(this.#baseXoConfig.ignores);
+        const configIgnores = (this.#xoConfig ?? []).slice(1)
+            .flatMap(config => isGlobalIgnoreConfig(config) ? arrify(config.ignores) : []);
+        const discoveryIgnores = [...configIgnores, ...cliIgnores];
+        const positiveGlobalIgnores = discoveryIgnores.filter(pattern => !pattern.startsWith('!'));
+        const reopenedDefaultPatterns = getReopenedDefaultPatterns(discoveryIgnores);
+        const files = await discoverLintFiles({
+            cwd: this.#linterOptions.cwd,
+            globs,
+            positiveGlobalIgnores,
+            discoveryIgnores,
+            reopenedDefaultPatterns,
         });
-        const rulesMeta = this.eslint.getRulesMetaForResults(results ?? []);
-        return this.processReport(results ?? [], { rulesMeta });
-    }
-    async calculateConfigForFile(filePath) {
-        await this.initEslint([filePath]);
-        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) {
-        await this.initEslint();
-        if (!this.eslint) {
-            throw new Error('Failed to initialize ESLint');
-        }
-        return this.eslint.loadFormatter(name);
+        return {
+            cliIgnores,
+            discoveryIgnores,
+            files,
+        };
     }
     /**
     Add virtual files to the config with a tsconfig approach.
     */
     async addVirtualFilesToConfig(files) {
-        if (!this.xoConfig) {
+        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 tsconfigPath = path.join(this.#cacheLocation, 'tsconfig.stdin.json');
+            const configIndex = this.#xoConfig.findIndex(configItem => {
                 const { languageOptions } = configItem;
-                const parserOptionsCandidate = languageOptions?.parserOptions;
-                const parserOptions = parserOptionsCandidate;
+                const parserOptions = languageOptions?.['parserOptions'];
                 return parserOptions?.project === tsconfigPath;
             });
             if (nextVirtualFiles.size > 0) {
                 const filesArray = [...nextVirtualFiles];
-                const relativeFiles = filesArray.map(file => path.relative(this.linterOptions.cwd, file));
+                const relativeFiles = filesArray.map(file => path.relative(this.#linterOptions.cwd, file));
                 const tsconfigContent = {
                     compilerOptions: {
                         ...tsconfigDefaults.compilerOptions,
@@ -426,9 +352,9 @@ export class Xo {
                     const parserOptions = {
                         projectService: false,
                         project: tsconfigPath,
-                        tsconfigRootDir: this.linterOptions.cwd,
+                        tsconfigRootDir: this.#linterOptions.cwd,
                     };
-                    this.xoConfig.push({
+                    this.#xoConfig.push({
                         files: relativeFiles,
                         languageOptions: {
                             parser: typescriptParser,
@@ -437,22 +363,22 @@ export class Xo {
                     });
                 }
                 else {
-                    const existingConfig = this.xoConfig[configIndex];
-                    this.xoConfig[configIndex] = {
+                    const existingConfig = this.#xoConfig[configIndex];
+                    this.#xoConfig[configIndex] = {
                         ...existingConfig,
                         files: relativeFiles,
                     };
                 }
-                this.virtualFiles.clear();
+                this.#virtualFiles.clear();
                 for (const file of nextVirtualFiles) {
-                    this.virtualFiles.add(file);
+                    this.#virtualFiles.add(file);
                 }
                 return;
             }
             if (configIndex >= 0) {
-                this.xoConfig.splice(configIndex, 1);
+                this.#xoConfig.splice(configIndex, 1);
             }
-            this.virtualFiles.clear();
+            this.#virtualFiles.clear();
             await fs.rm(tsconfigPath, { force: true });
         }
         catch (error) {
@@ -463,7 +389,7 @@ export class Xo {
     Add existing files to the config with an in-memory TypeScript Program.
     */
     addExistingFilesToConfig(files, program) {
-        if (!this.xoConfig || files.length === 0) {
+        if (!this.#xoConfig || files.length === 0) {
             return;
         }
         const parserOptions = {
@@ -474,7 +400,7 @@ export class Xo {
             parserOptions.programs = [program];
         }
         const config = {
-            files: files.map(file => path.relative(this.linterOptions.cwd, file)),
+            files: files.map(file => path.relative(this.#linterOptions.cwd, file)),
             languageOptions: {
                 parser: typescriptParser,
                 parserOptions,
@@ -485,11 +411,11 @@ export class Xo {
         // 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);
+            this.#fileConfigs.set(file, config);
         }
     }
     processReport(report, { rulesMeta = {} } = {}) {
-        if (this.linterOptions.quiet) {
+        if (this.#linterOptions.quiet) {
             report = ESLint.getErrorResults(report);
         }
         const result = {
@@ -502,11 +428,10 @@ export class Xo {
             const rules = [];
             for (const { usedDeprecatedRules } of report) {
                 for (const rule of usedDeprecatedRules) {
-                    if (seenRules.has(rule.ruleId)) {
-                        continue;
+                    if (!seenRules.has(rule.ruleId)) {
+                        seenRules.add(rule.ruleId);
+                        rules.push(rule);
                     }
-                    seenRules.add(rule.ruleId);
-                    rules.push(rule);
                 }
             }
             return rules;
@@ -528,6 +453,203 @@ export class Xo {
         }
         return statistics;
     }
+    /**
+    Throws if a suppressions location was provided but the file does not exist.
+    */
+    async assertSuppressionsFileExists() {
+        if (this.#linterOptions.suppressionsLocation === undefined) {
+            return;
+        }
+        const suppressionsFilePath = path.resolve(this.#linterOptions.cwd, this.#linterOptions.suppressionsLocation);
+        try {
+            await fs.access(suppressionsFilePath);
+        }
+        catch {
+            throw createErrorWithExitCode(suppressionsFileMissingErrorMessage, 2);
+        }
+    }
+    /**
+    Sets the XO config on the XO instance.
+    */
+    async setXoConfig() {
+        if (this.#xoConfig) {
+            return;
+        }
+        const { flatOptions } = await resolveXoConfig({
+            ...this.#linterOptions,
+        });
+        const { config: xoConfig, tsFilesGlob: tsGlob, tsFilesIgnoresGlob } = preProcessXoConfig([
+            this.#baseXoConfig,
+            ...flatOptions,
+        ]);
+        this.#xoConfig = xoConfig;
+        this.#tsFilesGlob.push(...tsGlob);
+        this.#tsFilesIgnoresGlob.push(...tsFilesIgnoresGlob);
+    }
+    setEslintConfig(cliIgnores = arrify(this.#baseXoConfig.ignores), stripDefaultIgnores = false) {
+        if (!this.#xoConfig) {
+            throw new Error('"Xo.setEslintConfig" failed');
+        }
+        // Combine base config with per-file configs from Map
+        // Deduplicate configs since multiple files can share the same config object
+        const [baseConfig = {}, ...resolvedConfigs] = this.#xoConfig;
+        const { ignores, ...configWithoutCliIgnores } = baseConfig;
+        const expandedResolvedConfigs = resolvedConfigs.map(config => expandGlobalIgnoreConfigForEslint(config));
+        const uniqueFileConfigs = [...new Set(this.#fileConfigs.values())];
+        const cliIgnoreConfig = cliIgnores.length > 0 ? [{ ignores: expandIgnoreNegationsForEslint(cliIgnores) }] : [];
+        const allConfigs = [configWithoutCliIgnores, ...expandedResolvedConfigs, ...cliIgnoreConfig, ...uniqueFileConfigs];
+        // Always regenerate to support instance reuse with new files
+        this.#eslintConfig = xoToEslintConfig(allConfigs);
+        if (stripDefaultIgnores) {
+            this.#eslintConfig = stripDefaultIgnoreConfigs(this.#eslintConfig);
+        }
+    }
+    /**
+    Ensures the cache directory exists. This needs to run once before both tsconfig handling and running ESLint occur.
+    */
+    async ensureCacheDirectory() {
+        try {
+            const cacheStats = await fs.stat(this.#cacheLocation);
+            // If file, re-create as directory
+            if (cacheStats.isFile()) {
+                await fs.rm(this.#cacheLocation, { recursive: true, force: true });
+                await fs.mkdir(this.#cacheLocation, { recursive: true });
+            }
+        }
+        catch (error) {
+            // If not exists, create the directory. Rethrow any other error (for example, permission issues).
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            await fs.mkdir(this.#cacheLocation, { recursive: true });
+        }
+    }
+    /**
+    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.
+    */
+    async handleUnincludedTsFiles(files) {
+        if (!this.#linterOptions.ts || !files || files.length === 0) {
+            return;
+        }
+        // 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 { program, existingFiles, virtualFiles } = handleTsconfig({
+            files: allTsFiles,
+            cwd: this.#linterOptions.cwd,
+            cacheLocation: this.#cacheLocation,
+        });
+        this.#fileConfigs.clear();
+        if (existingFiles.length > 0) {
+            this.addExistingFilesToConfig(existingFiles, program);
+        }
+        await this.addVirtualFilesToConfig(virtualFiles);
+    }
+    /**
+    Initializes the ESLint instance on the XO instance.
+    */
+    async initEslint(files, cliIgnores = arrify(this.#baseXoConfig.ignores), stripDefaultIgnores = false) {
+        await this.prepareEslintConfig(files, cliIgnores, stripDefaultIgnores);
+        if (!this.#xoConfig) {
+            throw new Error('"Xo.initEslint" failed');
+        }
+        const eslintOptions = {
+            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,
+        };
+        // Always create new instance to support reuse with updated config
+        // ESLint's file-based cache (cacheLocation) persists across instances
+        this.#eslint = new ESLint(eslintOptions);
+    }
+    /**
+    Create an ESLint flat config for editor integrations using the same XO pipeline as the CLI.
+    */
+    async getProjectEslintConfig() {
+        const { cliIgnores, files } = await this.discoverFiles([`**/*.{${allExtensions.join(',')}}`]);
+        return this.prepareEslintConfig(files, cliIgnores);
+    }
+    /**
+    Lints the files on the XO instance.
+
+    @param globs - Glob pattern to pass to `globby`.
+    @throws Error
+    */
+    async lintFiles(globs) {
+        if (globs === undefined || (Array.isArray(globs) && globs.length === 0)) {
+            globs = `**/*.{${allExtensions.join(',')}}`;
+        }
+        globs = arrify(globs);
+        // If any explicitly provided pattern is non-dynamic (a literal file path), throw when no files are found.
+        // Dynamic glob patterns matching nothing is acceptable — the project may simply have no matching files yet.
+        // The default glob substitution above is always dynamic, so this is false when no globs were provided.
+        const hasExplicitFilePaths = globs.some(glob => !isDynamicPattern(glob));
+        const { cliIgnores, discoveryIgnores, files } = await this.discoverFiles(globs);
+        await this.assertSuppressionsFileExists();
+        await this.initEslint(files, cliIgnores, true);
+        if (!this.#eslint) {
+            throw new Error('Failed to initialize ESLint');
+        }
+        const eslint = this.#eslint;
+        const ignoredResults = await getIgnoredExplicitFileResults(this.#linterOptions.cwd, globs, eslint, [...defaultIgnores, ...discoveryIgnores]);
+        if (files.length === 0) {
+            if (hasExplicitFilePaths && ignoredResults.length === 0) {
+                throw new Error(noFilesFoundErrorMessage);
+            }
+            return this.processReport(ignoredResults);
+        }
+        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.
+    */
+    async lintText(code, lintTextOptions) {
+        const { filePath, warnIgnored: shouldWarnIgnored } = lintTextOptions;
+        await this.assertSuppressionsFileExists();
+        await this.initEslint([filePath]);
+        if (!this.#eslint) {
+            throw new Error('Failed to initialize ESLint');
+        }
+        const results = await this.#eslint.lintText(code, {
+            filePath,
+            warnIgnored: shouldWarnIgnored,
+        });
+        const rulesMeta = this.#eslint.getRulesMetaForResults(results);
+        return this.processReport(results, { rulesMeta });
+    }
+    async calculateConfigForFile(filePath) {
+        await this.initEslint([filePath]);
+        if (!this.#eslint) {
+            throw new Error('Failed to initialize ESLint');
+        }
+        return this.#eslint.calculateConfigForFile(filePath);
+    }
+    async getFormatter(name) {
+        await this.initEslint();
+        if (!this.#eslint) {
+            throw new Error('Failed to initialize ESLint');
+        }
+        return this.#eslint.loadFormatter(name);
+    }
 }
 export default Xo;
 //# sourceMappingURL=xo.js.map