@alexlit/lint-kit 166.1.0 → 167.1.0

package/packages/config-eslint/node_modules/eslint/lib/config/config-loader.js

@@ -1,816 +0,0 @@
-/**
- * @fileoverview Utility to load config files
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const path = require("node:path");
-const fs = require("node:fs/promises");
-const findUp = require("find-up");
-const { pathToFileURL } = require("node:url");
-const debug = require("debug")("eslint:config-loader");
-const { FlatConfigArray } = require("./flat-config-array");
-const { WarningService } = require("../services/warning-service");
-
-//-----------------------------------------------------------------------------
-// Types
-//-----------------------------------------------------------------------------
-
-/** @typedef {import("../types").Linter.Config} Config */
-
-/**
- * @typedef {Object} ConfigLoaderOptions
- * @property {string|false|undefined} configFile The path to the config file to use.
- * @property {string} cwd The current working directory.
- * @property {boolean} ignoreEnabled Indicates if ignore patterns should be honored.
- * @property {Config|Array<Config>} [baseConfig] The base config to use.
- * @property {Array<Config>} [defaultConfigs] The default configs to use.
- * @property {Array<string>} [ignorePatterns] The ignore patterns to use.
- * @property {Config|Array<Config>} [overrideConfig] The override config to use.
- * @property {boolean} [hasUnstableNativeNodeJsTSConfigFlag] The flag to indicate whether the `unstable_native_nodejs_ts_config` flag is enabled.
- * @property {WarningService} [warningService] The warning service to use.
- */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const FLAT_CONFIG_FILENAMES = [
-	"eslint.config.js",
-	"eslint.config.mjs",
-	"eslint.config.cjs",
-	"eslint.config.ts",
-	"eslint.config.mts",
-	"eslint.config.cts",
-];
-
-const importedConfigFileModificationTime = new Map();
-
-/**
- * Asserts that the given file path is valid.
- * @param {string} filePath The file path to check.
- * @returns {void}
- * @throws {Error} If `filePath` is not a non-empty string.
- */
-function assertValidFilePath(filePath) {
-	if (!filePath || typeof filePath !== "string") {
-		throw new Error("'filePath' must be a non-empty string");
-	}
-}
-
-/**
- * Asserts that a configuration exists. A configuration exists if any
- * of the following are true:
- * - `configFilePath` is defined.
- * - `useConfigFile` is `false`.
- * @param {string|undefined} configFilePath The path to the config file.
- * @param {ConfigLoaderOptions} loaderOptions The options to use when loading configuration files.
- * @returns {void}
- * @throws {Error} If no configuration exists.
- */
-function assertConfigurationExists(configFilePath, loaderOptions) {
-	const { configFile: useConfigFile } = loaderOptions;
-
-	if (!configFilePath && useConfigFile !== false) {
-		const error = new Error("Could not find config file.");
-
-		error.messageTemplate = "config-file-missing";
-		throw error;
-	}
-}
-
-/**
- * Check if the file is a TypeScript file.
- * @param {string} filePath The file path to check.
- * @returns {boolean} `true` if the file is a TypeScript file, `false` if it's not.
- */
-function isFileTS(filePath) {
-	const fileExtension = path.extname(filePath);
-
-	return /^\.[mc]?ts$/u.test(fileExtension);
-}
-
-/**
- * Check if ESLint is running in Bun.
- * @returns {boolean} `true` if the ESLint is running Bun, `false` if it's not.
- */
-function isRunningInBun() {
-	return !!globalThis.Bun;
-}
-
-/**
- * Check if ESLint is running in Deno.
- * @returns {boolean} `true` if the ESLint is running in Deno, `false` if it's not.
- */
-function isRunningInDeno() {
-	return !!globalThis.Deno;
-}
-
-/**
- * Checks if native TypeScript support is
- * enabled in the current Node.js process.
- *
- * This function determines if the
- * {@linkcode NodeJS.ProcessFeatures.typescript | typescript}
- * feature is present in the
- * {@linkcode process.features} object
- * and if its value is either "strip" or "transform".
- * @returns {boolean} `true` if native TypeScript support is enabled, otherwise `false`.
- * @since 9.24.0
- */
-function isNativeTypeScriptSupportEnabled() {
-	return (
-		// eslint-disable-next-line n/no-unsupported-features/node-builtins -- it's still an experimental feature.
-		["strip", "transform"].includes(process.features.typescript)
-	);
-}
-
-/**
- * Load the TypeScript configuration file.
- * @param {string} filePath The absolute file path to load.
- * @param {URL} fileURL The file URL to load.
- * @param {number} mtime The last modified timestamp of the file.
- * @returns {Promise<any>} The configuration loaded from the file.
- * @since 9.24.0
- */
-async function loadTypeScriptConfigFileWithJiti(filePath, fileURL, mtime) {
-	const { createJiti, version: jitiVersion } =
-		// eslint-disable-next-line no-use-before-define -- `ConfigLoader.loadJiti` can be overwritten for testing
-		await ConfigLoader.loadJiti().catch(() => {
-			throw new Error(
-				"The 'jiti' library is required for loading TypeScript configuration files. Make sure to install it.",
-			);
-		});
-
-	// `createJiti` was added in jiti v2.
-	if (typeof createJiti !== "function") {
-		throw new Error(
-			"You are using an outdated version of the 'jiti' library. Please update to the latest version of 'jiti' to ensure compatibility and access to the latest features.",
-		);
-	}
-
-	/*
-	 * Disabling `moduleCache` allows us to reload a
-	 * config file when the last modified timestamp changes.
-	 */
-	const jitiOptions = {
-		moduleCache: false,
-	};
-
-	if (jitiVersion.startsWith("2.1.")) {
-		jitiOptions.interopDefault = false;
-	}
-
-	const jiti = createJiti(__filename, jitiOptions);
-	const config = await jiti.import(fileURL.href);
-
-	importedConfigFileModificationTime.set(filePath, mtime);
-
-	return config?.default ?? config;
-}
-
-/**
- * Dynamically imports a module from the given file path.
- * @param {string} filePath The absolute file path of the module to import.
- * @param {URL} fileURL The file URL to load.
- * @param {number} mtime The last modified timestamp of the file.
- * @returns {Promise<any>} - A {@linkcode Promise | promise} that resolves to the imported ESLint config.
- * @since 9.24.0
- */
-async function dynamicImportConfig(filePath, fileURL, mtime) {
-	const module = await import(fileURL.href);
-
-	importedConfigFileModificationTime.set(filePath, mtime);
-
-	return module.default;
-}
-
-/**
- * Load the config array from the given filename.
- * @param {string} filePath The filename to load from.
- * @param {boolean} hasUnstableNativeNodeJsTSConfigFlag The flag to indicate whether the `unstable_native_nodejs_ts_config` flag is enabled.
- * @returns {Promise<any>} The config loaded from the config file.
- */
-async function loadConfigFile(filePath, hasUnstableNativeNodeJsTSConfigFlag) {
-	debug(`Loading config from ${filePath}`);
-
-	const fileURL = pathToFileURL(filePath);
-
-	debug(`Config file URL is ${fileURL}`);
-
-	const mtime = (await fs.stat(filePath)).mtime.getTime();
-
-	/*
-	 * Append a query with the config file's modification time (`mtime`) in order
-	 * to import the current version of the config file. Without the query, `import()` would
-	 * cache the config file module by the pathname only, and then always return
-	 * the same version (the one that was actual when the module was imported for the first time).
-	 *
-	 * This ensures that the config file module is loaded and executed again
-	 * if it has been changed since the last time it was imported.
-	 * If it hasn't been changed, `import()` will just return the cached version.
-	 *
-	 * Note that we should not overuse queries (e.g., by appending the current time
-	 * to always reload the config file module) as that could cause memory leaks
-	 * because entries are never removed from the import cache.
-	 */
-	fileURL.searchParams.append("mtime", mtime);
-
-	/*
-	 * With queries, we can bypass the import cache. However, when import-ing a CJS module,
-	 * Node.js uses the require infrastructure under the hood. That includes the require cache,
-	 * which caches the config file module by its file path (queries have no effect).
-	 * Therefore, we also need to clear the require cache before importing the config file module.
-	 * In order to get the same behavior with ESM and CJS config files, in particular - to reload
-	 * the config file only if it has been changed, we track file modification times and clear
-	 * the require cache only if the file has been changed.
-	 */
-	if (importedConfigFileModificationTime.get(filePath) !== mtime) {
-		delete require.cache[filePath];
-	}
-
-	const isTS = isFileTS(filePath);
-	const isBun = isRunningInBun();
-	const isDeno = isRunningInDeno();
-
-	/*
-	 * If we are dealing with a TypeScript file, then we need to use `jiti` to load it
-	 * in Node.js. Deno and Bun both allow native importing of TypeScript files.
-	 *
-	 * When Node.js supports native TypeScript imports, we can remove this check.
-	 */
-
-	if (isTS) {
-		if (hasUnstableNativeNodeJsTSConfigFlag) {
-			if (isNativeTypeScriptSupportEnabled()) {
-				return await dynamicImportConfig(filePath, fileURL, mtime);
-			}
-
-			if (!("typescript" in process.features)) {
-				throw new Error(
-					"The unstable_native_nodejs_ts_config flag is not supported in older versions of Node.js.",
-				);
-			}
-
-			throw new Error(
-				"The unstable_native_nodejs_ts_config flag is enabled, but native TypeScript support is not enabled in the current Node.js process. You need to either enable native TypeScript support by passing --experimental-strip-types or remove the unstable_native_nodejs_ts_config flag.",
-			);
-		}
-
-		if (!isDeno && !isBun) {
-			return await loadTypeScriptConfigFileWithJiti(
-				filePath,
-				fileURL,
-				mtime,
-			);
-		}
-	}
-
-	// fallback to normal runtime behavior
-
-	return await dynamicImportConfig(filePath, fileURL, mtime);
-}
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-/**
- * Encapsulates the loading and caching of configuration files when looking up
- * from the file being linted.
- */
-class ConfigLoader {
-	/**
-	 * Map of config file paths to the config arrays for those directories.
-	 * @type {Map<string, FlatConfigArray|Promise<FlatConfigArray>>}
-	 */
-	#configArrays = new Map();
-
-	/**
-	 * Map of absolute directory names to the config file paths for those directories.
-	 * @type {Map<string, {configFilePath:string,basePath:string}|Promise<{configFilePath:string,basePath:string}>>}
-	 */
-	#configFilePaths = new Map();
-
-	/**
-	 * The options to use when loading configuration files.
-	 * @type {ConfigLoaderOptions}
-	 */
-	#options;
-
-	/**
-	 * Creates a new instance.
-	 * @param {ConfigLoaderOptions} options The options to use when loading configuration files.
-	 */
-	constructor(options) {
-		this.#options = options.warningService
-			? options
-			: { ...options, warningService: new WarningService() };
-	}
-
-	/**
-	 * Determines which config file to use. This is determined by seeing if an
-	 * override config file was specified, and if so, using it; otherwise, as long
-	 * as override config file is not explicitly set to `false`, it will search
-	 * upwards from `fromDirectory` for a file named `eslint.config.js`.
-	 * @param {string} fromDirectory The directory from which to start searching.
-	 * @returns {Promise<{configFilePath:string|undefined,basePath:string}>} Location information for
-	 *      the config file.
-	 */
-	async #locateConfigFileToUse(fromDirectory) {
-		// check cache first
-		if (this.#configFilePaths.has(fromDirectory)) {
-			return this.#configFilePaths.get(fromDirectory);
-		}
-
-		const resultPromise = ConfigLoader.locateConfigFileToUse({
-			useConfigFile: this.#options.configFile,
-			cwd: this.#options.cwd,
-			fromDirectory,
-		});
-
-		// ensure `ConfigLoader.locateConfigFileToUse` is called only once for `fromDirectory`
-		this.#configFilePaths.set(fromDirectory, resultPromise);
-
-		// Unwrap the promise. This is primarily for the sync `getCachedConfigArrayForPath` method.
-		const result = await resultPromise;
-
-		this.#configFilePaths.set(fromDirectory, result);
-
-		return result;
-	}
-
-	/**
-	 * Calculates the config array for this run based on inputs.
-	 * @param {string} configFilePath The absolute path to the config file to use if not overridden.
-	 * @param {string} basePath The base path to use for relative paths in the config file.
-	 * @returns {Promise<FlatConfigArray>} The config array for `eslint`.
-	 */
-	async #calculateConfigArray(configFilePath, basePath) {
-		// check for cached version first
-		if (this.#configArrays.has(configFilePath)) {
-			return this.#configArrays.get(configFilePath);
-		}
-
-		const configsPromise = ConfigLoader.calculateConfigArray(
-			configFilePath,
-			basePath,
-			this.#options,
-		);
-
-		// ensure `ConfigLoader.calculateConfigArray` is called only once for `configFilePath`
-		this.#configArrays.set(configFilePath, configsPromise);
-
-		// Unwrap the promise. This is primarily for the sync `getCachedConfigArrayForPath` method.
-		const configs = await configsPromise;
-
-		this.#configArrays.set(configFilePath, configs);
-
-		return configs;
-	}
-
-	/**
-	 * Returns the config file path for the given directory or file. This will either use
-	 * the override config file that was specified in the constructor options or
-	 * search for a config file from the directory.
-	 * @param {string} fileOrDirPath The file or directory path to get the config file path for.
-	 * @returns {Promise<string|undefined>} The config file path or `undefined` if not found.
-	 * @throws {Error} If `fileOrDirPath` is not a non-empty string.
-	 * @throws {Error} If `fileOrDirPath` is not an absolute path.
-	 */
-	async findConfigFileForPath(fileOrDirPath) {
-		assertValidFilePath(fileOrDirPath);
-
-		const absoluteDirPath = path.resolve(
-			this.#options.cwd,
-			path.dirname(fileOrDirPath),
-		);
-		const { configFilePath } =
-			await this.#locateConfigFileToUse(absoluteDirPath);
-
-		return configFilePath;
-	}
-
-	/**
-	 * Returns a configuration object for the given file based on the CLI options.
-	 * This is the same logic used by the ESLint CLI executable to determine
-	 * configuration for each file it processes.
-	 * @param {string} filePath The path of the file or directory to retrieve config for.
-	 * @returns {Promise<FlatConfigArray>} A configuration object for the file.
-	 * @throws {Error} If no configuration for `filePath` exists.
-	 */
-	async loadConfigArrayForFile(filePath) {
-		assertValidFilePath(filePath);
-
-		debug(`Calculating config for file ${filePath}`);
-
-		const configFilePath = await this.findConfigFileForPath(filePath);
-
-		assertConfigurationExists(configFilePath, this.#options);
-
-		return this.loadConfigArrayForDirectory(filePath);
-	}
-
-	/**
-	 * Returns a configuration object for the given directory based on the CLI options.
-	 * This is the same logic used by the ESLint CLI executable to determine
-	 * configuration for each file it processes.
-	 * @param {string} dirPath The path of the directory to retrieve config for.
-	 * @returns {Promise<FlatConfigArray>} A configuration object for the directory.
-	 */
-	async loadConfigArrayForDirectory(dirPath) {
-		assertValidFilePath(dirPath);
-
-		debug(`Calculating config for directory ${dirPath}`);
-
-		const absoluteDirPath = path.resolve(
-			this.#options.cwd,
-			path.dirname(dirPath),
-		);
-		const { configFilePath, basePath } =
-			await this.#locateConfigFileToUse(absoluteDirPath);
-
-		debug(`Using config file ${configFilePath} and base path ${basePath}`);
-		return this.#calculateConfigArray(configFilePath, basePath);
-	}
-
-	/**
-	 * Returns a configuration array for the given file based on the CLI options.
-	 * This is a synchronous operation and does not read any files from disk. It's
-	 * intended to be used in locations where we know the config file has already
-	 * been loaded and we just need to get the configuration for a file.
-	 * @param {string} filePath The path of the file to retrieve a config object for.
-	 * @returns {FlatConfigArray} A configuration object for the file.
-	 * @throws {Error} If `filePath` is not a non-empty string.
-	 * @throws {Error} If `filePath` is not an absolute path.
-	 * @throws {Error} If the config file was not already loaded.
-	 */
-	getCachedConfigArrayForFile(filePath) {
-		assertValidFilePath(filePath);
-
-		debug(`Looking up cached config for ${filePath}`);
-
-		return this.getCachedConfigArrayForPath(path.dirname(filePath));
-	}
-
-	/**
-	 * Returns a configuration array for the given directory based on the CLI options.
-	 * This is a synchronous operation and does not read any files from disk. It's
-	 * intended to be used in locations where we know the config file has already
-	 * been loaded and we just need to get the configuration for a file.
-	 * @param {string} fileOrDirPath The path of the directory to retrieve a config object for.
-	 * @returns {FlatConfigArray} A configuration object for the directory.
-	 * @throws {Error} If `dirPath` is not a non-empty string.
-	 * @throws {Error} If `dirPath` is not an absolute path.
-	 * @throws {Error} If the config file was not already loaded.
-	 */
-	getCachedConfigArrayForPath(fileOrDirPath) {
-		assertValidFilePath(fileOrDirPath);
-
-		debug(`Looking up cached config for ${fileOrDirPath}`);
-
-		const absoluteDirPath = path.resolve(this.#options.cwd, fileOrDirPath);
-
-		if (!this.#configFilePaths.has(absoluteDirPath)) {
-			throw new Error(`Could not find config file for ${fileOrDirPath}`);
-		}
-
-		const configFilePathInfo = this.#configFilePaths.get(absoluteDirPath);
-
-		if (typeof configFilePathInfo.then === "function") {
-			throw new Error(
-				`Config file path for ${fileOrDirPath} has not yet been calculated or an error occurred during the calculation`,
-			);
-		}
-
-		const { configFilePath } = configFilePathInfo;
-
-		const configArray = this.#configArrays.get(configFilePath);
-
-		if (!configArray || typeof configArray.then === "function") {
-			throw new Error(
-				`Config array for ${fileOrDirPath} has not yet been calculated or an error occurred during the calculation`,
-			);
-		}
-
-		return configArray;
-	}
-
-	/**
-	 * Used to import the jiti dependency. This method is exposed internally for testing purposes.
-	 * @returns {Promise<{createJiti: Function|undefined, version: string;}>} A promise that fulfills with an object containing the jiti module's createJiti function and version.
-	 */
-	static async loadJiti() {
-		const { createJiti } = await import("jiti");
-		const version = require("jiti/package.json").version;
-		return { createJiti, version };
-	}
-
-	/**
-	 * Determines which config file to use. This is determined by seeing if an
-	 * override config file was specified, and if so, using it; otherwise, as long
-	 * as override config file is not explicitly set to `false`, it will search
-	 * upwards from `fromDirectory` for a file named `eslint.config.js`.
-	 * This method is exposed internally for testing purposes.
-	 * @param {Object} [options] the options object
-	 * @param {string|false|undefined} options.useConfigFile The path to the config file to use.
-	 * @param {string} options.cwd Path to a directory that should be considered as the current working directory.
-	 * @param {string} [options.fromDirectory] The directory from which to start searching. Defaults to `cwd`.
-	 * @returns {Promise<{configFilePath:string|undefined,basePath:string}>} Location information for
-	 *      the config file.
-	 */
-	static async locateConfigFileToUse({
-		useConfigFile,
-		cwd,
-		fromDirectory = cwd,
-	}) {
-		// determine where to load config file from
-		let configFilePath;
-		let basePath = cwd;
-
-		if (typeof useConfigFile === "string") {
-			debug(`Override config file path is ${useConfigFile}`);
-			configFilePath = path.resolve(cwd, useConfigFile);
-			basePath = cwd;
-		} else if (useConfigFile !== false) {
-			debug("Searching for eslint.config.js");
-			configFilePath = await findUp(FLAT_CONFIG_FILENAMES, {
-				cwd: fromDirectory,
-			});
-
-			if (configFilePath) {
-				basePath = path.dirname(configFilePath);
-			}
-		}
-
-		return {
-			configFilePath,
-			basePath,
-		};
-	}
-
-	/**
-	 * Calculates the config array for this run based on inputs.
-	 * This method is exposed internally for testing purposes.
-	 * @param {string} configFilePath The absolute path to the config file to use if not overridden.
-	 * @param {string} basePath The base path to use for relative paths in the config file.
-	 * @param {ConfigLoaderOptions} options The options to use when loading configuration files.
-	 * @returns {Promise<FlatConfigArray>} The config array for `eslint`.
-	 */
-	static async calculateConfigArray(configFilePath, basePath, options) {
-		const {
-			cwd,
-			baseConfig,
-			ignoreEnabled,
-			ignorePatterns,
-			overrideConfig,
-			hasUnstableNativeNodeJsTSConfigFlag = false,
-			defaultConfigs = [],
-			warningService,
-		} = options;
-
-		debug(
-			`Calculating config array from config file ${configFilePath} and base path ${basePath}`,
-		);
-
-		const configs = new FlatConfigArray(baseConfig || [], {
-			basePath,
-			shouldIgnore: ignoreEnabled,
-		});
-
-		// load config file
-		if (configFilePath) {
-			debug(`Loading config file ${configFilePath}`);
-			const fileConfig = await loadConfigFile(
-				configFilePath,
-				hasUnstableNativeNodeJsTSConfigFlag,
-			);
-
-			/*
-			 * It's possible that a config file could be empty or else
-			 * have an empty object or array. In this case, we want to
-			 * warn the user that they have an empty config.
-			 *
-			 * An empty CommonJS file exports an empty object while
-			 * an empty ESM file exports undefined.
-			 */
-
-			let emptyConfig = typeof fileConfig === "undefined";
-
-			debug(
-				`Config file ${configFilePath} is ${emptyConfig ? "empty" : "not empty"}`,
-			);
-
-			if (!emptyConfig) {
-				if (Array.isArray(fileConfig)) {
-					if (fileConfig.length === 0) {
-						debug(
-							`Config file ${configFilePath} is an empty array`,
-						);
-						emptyConfig = true;
-					} else {
-						configs.push(...fileConfig);
-					}
-				} else {
-					if (
-						typeof fileConfig === "object" &&
-						fileConfig !== null &&
-						Object.keys(fileConfig).length === 0
-					) {
-						debug(
-							`Config file ${configFilePath} is an empty object`,
-						);
-						emptyConfig = true;
-					} else {
-						configs.push(fileConfig);
-					}
-				}
-			}
-
-			if (emptyConfig) {
-				warningService.emitEmptyConfigWarning(configFilePath);
-			}
-		}
-
-		// add in any configured defaults
-		configs.push(...defaultConfigs);
-
-		// append command line ignore patterns
-		if (ignorePatterns && ignorePatterns.length > 0) {
-			/*
-			 * Ignore patterns are added to the end of the config array
-			 * so they can override default ignores.
-			 */
-			configs.push({
-				basePath: cwd,
-				ignores: ignorePatterns,
-			});
-		}
-
-		if (overrideConfig) {
-			if (Array.isArray(overrideConfig)) {
-				configs.push(...overrideConfig);
-			} else {
-				configs.push(overrideConfig);
-			}
-		}
-
-		await configs.normalize();
-
-		return configs;
-	}
-}
-
-/**
- * Encapsulates the loading and caching of configuration files when looking up
- * from the current working directory.
- */
-class LegacyConfigLoader extends ConfigLoader {
-	/**
-	 * The options to use when loading configuration files.
-	 * @type {ConfigLoaderOptions}
-	 */
-	#options;
-
-	/**
-	 * The cached config file path for this instance.
-	 * @type {Promise<{configFilePath:string,basePath:string}|undefined>}
-	 */
-	#configFilePath;
-
-	/**
-	 * The cached config array for this instance.
-	 * @type {FlatConfigArray|Promise<FlatConfigArray>}
-	 */
-	#configArray;
-
-	/**
-	 * Creates a new instance.
-	 * @param {ConfigLoaderOptions} options The options to use when loading configuration files.
-	 */
-	constructor(options) {
-		const normalizedOptions = options.warningService
-			? options
-			: { ...options, warningService: new WarningService() };
-		super(normalizedOptions);
-		this.#options = normalizedOptions;
-	}
-
-	/**
-	 * Determines which config file to use. This is determined by seeing if an
-	 * override config file was specified, and if so, using it; otherwise, as long
-	 * as override config file is not explicitly set to `false`, it will search
-	 * upwards from the cwd for a file named `eslint.config.js`.
-	 * @returns {Promise<{configFilePath:string|undefined,basePath:string}>} Location information for
-	 *      the config file.
-	 */
-	#locateConfigFileToUse() {
-		if (!this.#configFilePath) {
-			this.#configFilePath = ConfigLoader.locateConfigFileToUse({
-				useConfigFile: this.#options.configFile,
-				cwd: this.#options.cwd,
-			});
-		}
-
-		return this.#configFilePath;
-	}
-
-	/**
-	 * Calculates the config array for this run based on inputs.
-	 * @param {string} configFilePath The absolute path to the config file to use if not overridden.
-	 * @param {string} basePath The base path to use for relative paths in the config file.
-	 * @returns {Promise<FlatConfigArray>} The config array for `eslint`.
-	 */
-	async #calculateConfigArray(configFilePath, basePath) {
-		// check for cached version first
-		if (this.#configArray) {
-			return this.#configArray;
-		}
-
-		// ensure `ConfigLoader.calculateConfigArray` is called only once
-		this.#configArray = ConfigLoader.calculateConfigArray(
-			configFilePath,
-			basePath,
-			this.#options,
-		);
-
-		// Unwrap the promise. This is primarily for the sync `getCachedConfigArrayForPath` method.
-		this.#configArray = await this.#configArray;
-
-		return this.#configArray;
-	}
-
-	/**
-	 * Returns the config file path for the given directory. This will either use
-	 * the override config file that was specified in the constructor options or
-	 * search for a config file from the directory of the file being linted.
-	 * @param {string} dirPath The directory path to get the config file path for.
-	 * @returns {Promise<string|undefined>} The config file path or `undefined` if not found.
-	 * @throws {Error} If `fileOrDirPath` is not a non-empty string.
-	 * @throws {Error} If `fileOrDirPath` is not an absolute path.
-	 */
-	async findConfigFileForPath(dirPath) {
-		assertValidFilePath(dirPath);
-
-		const { configFilePath } = await this.#locateConfigFileToUse();
-
-		return configFilePath;
-	}
-
-	/**
-	 * Returns a configuration object for the given file based on the CLI options.
-	 * This is the same logic used by the ESLint CLI executable to determine
-	 * configuration for each file it processes.
-	 * @param {string} dirPath The path of the directory to retrieve config for.
-	 * @returns {Promise<FlatConfigArray>} A configuration object for the file.
-	 */
-	async loadConfigArrayForDirectory(dirPath) {
-		assertValidFilePath(dirPath);
-
-		debug(`[Legacy]: Calculating config for ${dirPath}`);
-
-		const { configFilePath, basePath } =
-			await this.#locateConfigFileToUse();
-
-		debug(
-			`[Legacy]: Using config file ${configFilePath} and base path ${basePath}`,
-		);
-		return this.#calculateConfigArray(configFilePath, basePath);
-	}
-
-	/**
-	 * Returns a configuration array for the given directory based on the CLI options.
-	 * This is a synchronous operation and does not read any files from disk. It's
-	 * intended to be used in locations where we know the config file has already
-	 * been loaded and we just need to get the configuration for a file.
-	 * @param {string} dirPath The path of the directory to retrieve a config object for.
-	 * @returns {FlatConfigArray} A configuration object for the file.
-	 * @throws {Error} If `dirPath` is not a non-empty string.
-	 * @throws {Error} If `dirPath` is not an absolute path.
-	 * @throws {Error} If the config file was not already loaded.
-	 */
-	getCachedConfigArrayForPath(dirPath) {
-		assertValidFilePath(dirPath);
-
-		debug(`[Legacy]: Looking up cached config for ${dirPath}`);
-
-		if (!this.#configArray) {
-			throw new Error(`Could not find config file for ${dirPath}`);
-		}
-
-		if (typeof this.#configArray.then === "function") {
-			throw new Error(
-				`Config array for ${dirPath} has not yet been calculated or an error occurred during the calculation`,
-			);
-		}
-
-		return this.#configArray;
-	}
-}
-
-module.exports = { ConfigLoader, LegacyConfigLoader };