xo 3.0.1 → 3.0.2

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

@@ -1,21 +1,14 @@
-import ts from 'typescript';
 /**
-This function checks if the files are matched by the tsconfig include, exclude, and it returns the unmatched files.
+This function checks if the files are matched by the tsconfig include/exclude, and returns the unmatched files.
 
-If no tsconfig is found, it will create an in-memory TypeScript Program for type-aware linting.
+All unincluded files are routed through a generated tsconfig (`parserOptions.project`) so that autofix works correctly across multiple ESLint passes. The in-memory Program approach is intentionally not used here because `@typescript-eslint/typescript-estree` always returns the AST built from the original file text when using `parserOptions.programs`, ignoring the updated `code` ESLint passes on subsequent fix passes, which causes file corruption.
 
 @param options - The options for handling the tsconfig.
 @param options.files - The TypeScript files to check against the tsconfig.
 @param options.cwd - The current working directory.
-@param options.cacheLocation - The cache directory used to detect virtual/stdin files.
-@returns The unmatched files and an in-memory TypeScript Program.
+@returns The unincluded files.
 */
-export declare function handleTsconfig({ files, cwd, cacheLocation }: {
+export declare function handleTsconfig({ files, cwd }: {
     files: string[];
     cwd: string;
-    cacheLocation?: string;
-}): {
-    existingFiles: string[];
-    virtualFiles: string[];
-    program: ts.Program | undefined;
-};
+}): string[];

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

@@ -1,9 +1,7 @@
 import path from 'node:path';
-import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import ts from 'typescript';
 import { getTsconfig, createFilesMatcher } from 'get-tsconfig';
-import { tsconfigDefaults } from './constants.js';
 let hasWarnedAboutTypeScriptVersion = false;
 /**
 Warns once if the project's own TypeScript is an older major than the version XO bundles. Mixing TypeScript versions in one process can crash type-aware linting (notably under pnpm), because the TypeFlags enum was renumbered in TypeScript 6.
@@ -29,65 +27,17 @@ const warnOnOutdatedProjectTypeScript = (cwd) => {
     hasWarnedAboutTypeScriptVersion = true;
     console.warn(`XO bundles TypeScript ${ts.version}, but your project has TypeScript ${projectVersion}. Mixing TypeScript versions in one process can crash type-aware linting (notably with pnpm). Upgrade your project's \`typescript\` to ${bundledMajor} or later, or pin it (for example, a pnpm \`overrides\` entry).`);
 };
-const createInMemoryProgram = (files, cwd) => {
-    if (files.length === 0) {
-        return undefined;
-    }
-    try {
-        const compilerOptions = getFallbackCompilerOptions(cwd);
-        const program = ts.createProgram(files, { ...compilerOptions });
-        Object.defineProperty(program, 'toJSON', {
-            value: () => ({
-                __type: 'TypeScriptProgram',
-                files: files.map(file => path.relative(cwd, file)),
-            }),
-            configurable: true,
-        });
-        return program;
-    }
-    catch (error) {
-        console.warn('XO: Failed to create TypeScript Program for type-aware linting. Continuing without type information for unincluded files.', error instanceof Error ? error.message : String(error));
-        return undefined;
-    }
-};
-const fallbackCompilerOptionsCache = new Map();
-const getFallbackCompilerOptions = (cwd) => {
-    const cacheKey = path.resolve(cwd);
-    const cached = fallbackCompilerOptionsCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const compilerOptionsResult = ts.convertCompilerOptionsFromJson(tsconfigDefaults.compilerOptions ?? {}, cacheKey);
-    if (compilerOptionsResult.errors.length > 0) {
-        throw new Error('XO: Invalid default TypeScript compiler options');
-    }
-    const compilerOptions = {
-        ...compilerOptionsResult.options,
-        // Anchor module and `@types` resolution to the project directory. Without `configFilePath`, an option-only program resolves these from `process.cwd()`, which differs from `cwd` for programmatic callers. The file need not exist; only its directory is used.
-        configFilePath: path.join(cacheKey, 'tsconfig.json'),
-        esModuleInterop: true,
-        resolveJsonModule: true,
-        allowJs: true,
-        skipLibCheck: true,
-        skipDefaultLibCheck: true,
-        // TypeScript 6 only auto-includes `@types/*` packages when `types` contains `'*'`. Without this, files outside the tsconfig resolve imports to `any` and type-aware rules misfire.
-        types: ['*'],
-    };
-    fallbackCompilerOptionsCache.set(cacheKey, compilerOptions);
-    return compilerOptions;
-};
 /**
-This function checks if the files are matched by the tsconfig include, exclude, and it returns the unmatched files.
+This function checks if the files are matched by the tsconfig include/exclude, and returns the unmatched files.
 
-If no tsconfig is found, it will create an in-memory TypeScript Program for type-aware linting.
+All unincluded files are routed through a generated tsconfig (`parserOptions.project`) so that autofix works correctly across multiple ESLint passes. The in-memory Program approach is intentionally not used here because `@typescript-eslint/typescript-estree` always returns the AST built from the original file text when using `parserOptions.programs`, ignoring the updated `code` ESLint passes on subsequent fix passes, which causes file corruption.
 
 @param options - The options for handling the tsconfig.
 @param options.files - The TypeScript files to check against the tsconfig.
 @param options.cwd - The current working directory.
-@param options.cacheLocation - The cache directory used to detect virtual/stdin files.
-@returns The unmatched files and an in-memory TypeScript Program.
+@returns The unincluded files.
 */
-export function handleTsconfig({ files, cwd, cacheLocation }) {
+export function handleTsconfig({ files, cwd }) {
     warnOnOutdatedProjectTypeScript(cwd);
     const unincludedFiles = [];
     const filesMatcherCache = new Map();
@@ -108,39 +58,6 @@ export function handleTsconfig({ files, cwd, cacheLocation }) {
         }
         unincludedFiles.push(filePath);
     }
-    if (unincludedFiles.length === 0) {
-        return { existingFiles: [], virtualFiles: [], program: undefined };
-    }
-    // Separate real files from virtual/cache files
-    // Virtual files include: stdin files (in cache dir), non-existent files
-    // TypeScript will surface opaque diagnostics for missing files; pre-filter so we only pay the program cost for real files.
-    const existingFiles = [];
-    const virtualFiles = [];
-    for (const file of unincludedFiles) {
-        // Files that don't exist are always virtual
-        if (!fs.existsSync(file)) {
-            virtualFiles.push(file);
-            continue;
-        }
-        // Check if file is in cache directory (like stdin files)
-        // These need tsconfig treatment even though they exist on disk
-        if (cacheLocation !== undefined) {
-            const absolutePath = path.resolve(file);
-            const cacheRoot = path.resolve(cacheLocation);
-            const relativeToCache = path.relative(cacheRoot, absolutePath);
-            // File is inside cache if relative path doesn't escape (no '..')
-            const isInCache = !relativeToCache.startsWith('..') && !path.isAbsolute(relativeToCache);
-            if (isInCache) {
-                virtualFiles.push(file);
-                continue;
-            }
-        }
-        existingFiles.push(file);
-    }
-    return {
-        existingFiles,
-        virtualFiles,
-        program: createInMemoryProgram(existingFiles, cwd),
-    };
+    return unincludedFiles;
 }
 //# sourceMappingURL=handle-ts-files.js.map

package/dist/lib/xo.d.ts

@@ -23,13 +23,11 @@ export declare class Xo {
     private prepareEslintConfig;
     private discoverFiles;
     /**
-    Add virtual files to the config with a tsconfig approach.
-    */
-    private addVirtualFilesToConfig;
-    /**
-    Add existing files to the config with an in-memory TypeScript Program.
+    Add unincluded files to the config with a generated tsconfig approach. Passing an empty array removes the generated config entry.
+
+    This uses `parserOptions.project` rather than an in-memory `parserOptions.programs`. A pre-built program's AST is built once from the original file text and is never updated between ESLint's multiple `--fix` passes, so stale offsets corrupt the output. A file-based project is re-read on each pass, so autofix stays correct.
     */
-    private addExistingFilesToConfig;
+    private addUnincludedFilesToConfig;
     private processReport;
     private getReportStatistics;
     /**
@@ -46,7 +44,7 @@ export declare class Xo {
     */
     ensureCacheDirectory(): Promise<void>;
     /**
-    Checks every TS file to ensure its included in the tsconfig and any that are not included are added to an in-memory TypeScript Program for type aware linting.
+    Checks every TS file to ensure it is included in the tsconfig. Any that are not included are routed through a generated tsconfig (`tsconfig.generated.json`) so that autofix works correctly across multiple ESLint passes.
 
     @param files - The TypeScript files being linted.
     */

package/dist/lib/xo.js

@@ -3,6 +3,7 @@ import os from 'node:os';
 import syncFs from 'node:fs';
 import fs from 'node:fs/promises';
 import process from 'node:process';
+import { createHash } from 'node:crypto';
 import { ESLint } from 'eslint';
 import findCacheDirectory from 'find-cache-directory';
 import { globby, isDynamicPattern } from 'globby';
@@ -39,6 +40,17 @@ const createIgnoredLintResult = (filePath) => ({
 });
 const normalizeGlobPath = (filePath) => filePath.split(path.sep).join('/');
 const pathMatchesPattern = (filePath, pattern) => micromatch.isMatch(normalizeGlobPath(filePath), normalizeGlobPath(pattern), { dot: true });
+const isPathInside = (parentPath, childPath) => {
+    const relativePath = path.relative(parentPath, childPath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+};
+const getGeneratedTsconfigPath = (directory, files) => {
+    const hash = createHash('sha256')
+        .update(JSON.stringify(files.toSorted((first, second) => first.localeCompare(second))))
+        .digest('hex')
+        .slice(0, 16);
+    return path.join(directory, `tsconfig.generated.${hash}.json`);
+};
 const isIgnoredByPatterns = (filePath, patterns) => {
     let isIgnored = false;
     for (const pattern of patterns) {
@@ -233,6 +245,14 @@ export class Xo {
     */
     #cacheLocation;
     /**
+    Directory for generated tsconfigs for unincluded TypeScript files.
+    */
+    #generatedTsconfigDirectory;
+    /**
+    File path to the currently active generated tsconfig.
+    */
+    #currentGeneratedTsconfigPath;
+    /**
     XO config derived from both the base config and the resolved flat config.
     */
     #xoConfig;
@@ -258,17 +278,6 @@ export class Xo {
     We use this to also add negative glob patterns in case a user overrides the parserOptions in their XO config.
     */
     #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();
-    /**
-    Track virtual/stdin files that share a single tsconfig.stdin.json.
-    These are handled differently from regular files.
-    */
-    #virtualFiles = new Set();
     constructor(_linterOptions, _baseXoConfig = {}) {
         this.#linterOptions = _linterOptions;
         this.#baseXoConfig = _baseXoConfig;
@@ -284,6 +293,9 @@ export class Xo {
         }
         const backupCacheLocation = path.join(os.tmpdir(), cacheDirName);
         this.#cacheLocation = findCacheDirectory({ name: cacheDirName, cwd: this.#linterOptions.cwd }) ?? backupCacheLocation;
+        this.#generatedTsconfigDirectory = isPathInside(this.#linterOptions.cwd, this.#cacheLocation)
+            ? this.#cacheLocation
+            : path.join(this.#linterOptions.cwd, 'node_modules', '.cache', cacheDirName);
     }
     /**
     Initializes the ESLint flat config on the XO instance.
@@ -320,100 +332,74 @@ export class Xo {
         };
     }
     /**
-    Add virtual files to the config with a tsconfig approach.
+    Add unincluded files to the config with a generated tsconfig approach. Passing an empty array removes the generated config entry.
+
+    This uses `parserOptions.project` rather than an in-memory `parserOptions.programs`. A pre-built program's AST is built once from the original file text and is never updated between ESLint's multiple `--fix` passes, so stale offsets corrupt the output. A file-based project is re-read on each pass, so autofix stays correct.
     */
-    async addVirtualFilesToConfig(files) {
+    async addUnincludedFilesToConfig(files) {
         if (!this.#xoConfig) {
             return;
         }
         try {
-            const nextVirtualFiles = new Set(files);
-            const tsconfigPath = path.join(this.#cacheLocation, 'tsconfig.stdin.json');
-            const configIndex = this.#xoConfig.findIndex(configItem => {
-                const { languageOptions } = configItem;
-                const 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 tsconfigContent = {
-                    compilerOptions: {
-                        ...tsconfigDefaults.compilerOptions,
-                        module: 'ESNext',
-                        moduleResolution: 'NodeNext',
-                        esModuleInterop: true,
-                        skipLibCheck: true,
-                        // TypeScript 6 only auto-includes `@types/*` packages when `types` contains `'*'`. Without this, virtual/stdin files resolve imports to `any` and type-aware rules misfire.
-                        types: ['*'],
-                    },
-                    files: filesArray,
-                };
-                await fs.writeFile(tsconfigPath, JSON.stringify(tsconfigContent, null, 2));
-                if (configIndex === -1) {
-                    const parserOptions = {
-                        projectService: false,
-                        project: tsconfigPath,
-                        tsconfigRootDir: this.#linterOptions.cwd,
-                    };
-                    this.#xoConfig.push({
-                        files: relativeFiles,
-                        languageOptions: {
-                            parser: typescriptParser,
-                            parserOptions,
-                        },
-                    });
-                }
-                else {
-                    const existingConfig = this.#xoConfig[configIndex];
-                    this.#xoConfig[configIndex] = {
-                        ...existingConfig,
-                        files: relativeFiles,
-                    };
+            const previousTsconfigPath = this.#currentGeneratedTsconfigPath;
+            const configIndex = previousTsconfigPath === undefined
+                ? -1
+                : this.#xoConfig.findIndex(configItem => {
+                    const { languageOptions } = configItem;
+                    const parserOptions = languageOptions?.['parserOptions'];
+                    return parserOptions?.project === previousTsconfigPath;
+                });
+            if (files.length === 0) {
+                if (configIndex !== -1) {
+                    this.#xoConfig.splice(configIndex, 1);
                 }
-                this.#virtualFiles.clear();
-                for (const file of nextVirtualFiles) {
-                    this.#virtualFiles.add(file);
+                if (previousTsconfigPath !== undefined) {
+                    this.#currentGeneratedTsconfigPath = undefined;
                 }
                 return;
             }
-            if (configIndex >= 0) {
-                this.#xoConfig.splice(configIndex, 1);
+            const tsconfigPath = getGeneratedTsconfigPath(this.#generatedTsconfigDirectory, files);
+            // The generated tsconfig references files by absolute path; the ESLint config matches them by path relative to `cwd`.
+            const relativeFiles = files.map(file => path.relative(this.#linterOptions.cwd, file));
+            const tsconfigContent = {
+                compilerOptions: {
+                    ...tsconfigDefaults.compilerOptions,
+                    module: 'ESNext',
+                    moduleResolution: 'NodeNext',
+                    esModuleInterop: true,
+                    resolveJsonModule: true,
+                    skipLibCheck: true,
+                    // JS files are routed here too (type-aware rules apply to JS). Without `allowJs`, TypeScript does not load them as source files, so the parser reports "file not found in project".
+                    allowJs: true,
+                    // TypeScript 6 only auto-includes `@types/*` packages when `types` contains `'*'`. Without this, unincluded files resolve imports to `any` and type-aware rules misfire.
+                    types: ['*'],
+                },
+                files,
+            };
+            await fs.mkdir(path.dirname(tsconfigPath), { recursive: true });
+            await fs.writeFile(tsconfigPath, JSON.stringify(tsconfigContent, null, 2));
+            this.#currentGeneratedTsconfigPath = tsconfigPath;
+            const parserOptions = {
+                projectService: false,
+                project: tsconfigPath,
+                tsconfigRootDir: this.#linterOptions.cwd,
+            };
+            const generatedConfig = {
+                files: relativeFiles,
+                languageOptions: {
+                    parser: typescriptParser,
+                    parserOptions,
+                },
+            };
+            if (configIndex === -1) {
+                this.#xoConfig.push(generatedConfig);
+            }
+            else {
+                this.#xoConfig[configIndex] = generatedConfig;
             }
-            this.#virtualFiles.clear();
-            await fs.rm(tsconfigPath, { force: true });
         }
         catch (error) {
-            console.warn('XO: Failed to create tsconfig for virtual files. Type-aware linting will be disabled for these files.', error instanceof Error ? error.message : String(error));
-        }
-    }
-    /**
-    Add existing files to the config with an in-memory TypeScript Program.
-    */
-    addExistingFilesToConfig(files, program) {
-        if (!this.#xoConfig || files.length === 0) {
-            return;
-        }
-        const parserOptions = {
-            project: false,
-            projectService: false,
-        };
-        if (program) {
-            parserOptions.programs = [program];
-        }
-        const config = {
-            files: files.map(file => path.relative(this.#linterOptions.cwd, file)),
-            languageOptions: {
-                parser: typescriptParser,
-                parserOptions,
-            },
-        };
-        // IMPORTANT: All files intentionally share the same config object reference for memory efficiency.
-        // This prevents unbounded memory growth in long-running processes (e.g., language servers).
-        // The config is immutable after creation, so sharing is safe.
-        // Deduplication happens in setEslintConfig() via Set to avoid duplicate configs in the final array.
-        for (const file of files) {
-            this.#fileConfigs.set(file, config);
+            console.warn('XO: Failed to create tsconfig for unincluded files. Type-aware linting will be disabled for these files.', error instanceof Error ? error.message : String(error));
         }
     }
     processReport(report, { rulesMeta = {} } = {}) {
@@ -492,14 +478,11 @@ export class Xo {
         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];
+        const allConfigs = [configWithoutCliIgnores, ...expandedResolvedConfigs, ...cliIgnoreConfig];
         // Always regenerate to support instance reuse with new files
         this.#eslintConfig = xoToEslintConfig(allConfigs);
         if (stripDefaultIgnores) {
@@ -527,33 +510,24 @@ export class Xo {
         }
     }
     /**
-    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.
+    Checks every TS file to ensure it is included in the tsconfig. Any that are not included are routed through a generated tsconfig (`tsconfig.generated.json`) so that autofix works correctly across multiple ESLint passes.
 
     @param files - The TypeScript files being linted.
     */
     async handleUnincludedTsFiles(files) {
-        if (!this.#linterOptions.ts || !files || files.length === 0) {
+        if (!this.#linterOptions.ts) {
             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([]);
-            }
+        if (!files || files.length === 0) {
+            await this.addUnincludedFilesToConfig([]);
             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);
+        // Get ALL TypeScript files being linted
+        const allTsFiles = matchFilesForTsConfig(this.#linterOptions.cwd, files, this.#tsFilesGlob, this.#tsFilesIgnoresGlob);
+        const unincludedFiles = allTsFiles.length === 0
+            ? []
+            : handleTsconfig({ files: allTsFiles, cwd: this.#linterOptions.cwd });
+        await this.addUnincludedFilesToConfig(unincludedFiles);
     }
     /**
     Initializes the ESLint instance on the XO instance.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xo",
-	"version": "3.0.1",
+	"version": "3.0.2",
 	"description": "JavaScript/TypeScript linter (ESLint wrapper) with great defaults",
 	"license": "MIT",
 	"repository": "xojs/xo",