eslint 9.11.1 → 9.13.0

package/lib/eslint/eslint.js

@@ -12,10 +12,10 @@
 const fs = require("node:fs/promises");
 const { existsSync } = require("node:fs");
 const path = require("node:path");
-const findUp = require("find-up");
 const { version } = require("../../package.json");
 const { Linter } = require("../linter");
 const { getRuleFromConfig } = require("../config/flat-config-helpers");
+const { defaultConfig } = require("../config/default-config");
 const {
     Legacy: {
         ConfigOps: {
@@ -39,9 +39,9 @@ const {
     processOptions
 } = require("./eslint-helpers");
 const { pathToFileURL } = require("node:url");
-const { FlatConfigArray } = require("../config/flat-config-array");
 const LintResultCache = require("../cli-engine/lint-result-cache");
 const { Retrier } = require("@humanwhocodes/retry");
+const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
 
 /*
  * This is necessary to allow overwriting writeFile for testing purposes.
@@ -53,6 +53,7 @@ const { Retrier } = require("@humanwhocodes/retry");
 //------------------------------------------------------------------------------
 
 // For VSCode IntelliSense
+/** @typedef {import("../cli-engine/cli-engine").ConfigArray} ConfigArray */
 /** @typedef {import("../shared/types").ConfigData} ConfigData */
 /** @typedef {import("../shared/types").DeprecatedRuleInfo} DeprecatedRuleInfo */
 /** @typedef {import("../shared/types").LintMessage} LintMessage */
@@ -97,24 +98,8 @@ const { Retrier } = require("@humanwhocodes/retry");
 // Helpers
 //------------------------------------------------------------------------------
 
-const FLAT_CONFIG_FILENAMES = [
-    "eslint.config.js",
-    "eslint.config.mjs",
-    "eslint.config.cjs"
-];
-const FLAT_CONFIG_FILENAMES_WITH_TS = [
-    ...FLAT_CONFIG_FILENAMES,
-    "eslint.config.ts",
-    "eslint.config.mts",
-    "eslint.config.cts"
-];
 const debug = require("debug")("eslint:eslint");
 const privateMembers = new WeakMap();
-
-/**
- * @type {Map<string, string>}
- */
-const importedConfigFileModificationTime = new Map();
 const removedFormatters = new Set([
     "checkstyle",
     "codeframe",
@@ -196,12 +181,13 @@ const usedDeprecatedRulesCache = new WeakMap();
  */
 function getOrFindUsedDeprecatedRules(eslint, maybeFilePath) {
     const {
-        configs,
-        options: { cwd }
+        options: { cwd },
+        configLoader
     } = privateMembers.get(eslint);
     const filePath = path.isAbsolute(maybeFilePath)
         ? maybeFilePath
         : getPlaceholderPath(cwd);
+    const configs = configLoader.getCachedConfigArrayForFile(filePath);
     const config = configs.getConfig(filePath);
 
     // Most files use the same config, so cache it.
@@ -270,269 +256,38 @@ function compareResultsByFilePath(a, b) {
     return 0;
 }
 
-/**
- * Searches from the current working directory up until finding the
- * given flat config filename.
- * @param {string} cwd The current working directory to search from.
- * @param {boolean} hasUnstableTSConfigFlag `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
- * @returns {Promise<string|undefined>} The filename if found or `undefined` if not.
- */
-function findFlatConfigFile(cwd, hasUnstableTSConfigFlag) {
-    const filenames = hasUnstableTSConfigFlag ? FLAT_CONFIG_FILENAMES_WITH_TS : FLAT_CONFIG_FILENAMES;
-
-    return findUp(
-        filenames,
-        { cwd }
-    );
-}
-
-/**
- * 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;
-}
-
-/**
- * Load the config array from the given filename.
- * @param {string} filePath The filename to load from.
- * @param {boolean} hasUnstableTSConfigFlag `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
- * @returns {Promise<any>} The config loaded from the config file.
- */
-async function loadFlatConfigFile(filePath, hasUnstableTSConfigFlag) {
-    debug(`Loading config from ${filePath}`);
-
-    const fileURL = pathToFileURL(filePath);
-
-    debug(`Config file URL is ${fileURL}`);
-
-    const mtime = (await fs.stat(filePath)).mtime.getTime().toString();
-
-    /*
-     * 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) && hasUnstableTSConfigFlag;
-
-    const isBun = isRunningInBun();
-
-    const isDeno = isRunningInDeno();
-
-    if (isTS && !isDeno && !isBun) {
-
-        const createJiti = await import("jiti").then(jitiModule => jitiModule.default, () => {
-            throw new Error("The 'jiti' library is required for loading TypeScript configuration files. Make sure to install it.");
-        });
-
-        /*
-         * Disabling `moduleCache` allows us to reload a
-         * config file when the last modified timestamp changes.
-         */
-
-        const jiti = createJiti(__filename, { moduleCache: false });
-
-        if (typeof jiti?.import !== "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.");
-        }
-
-        const config = await jiti.import(fileURL.href);
-
-        importedConfigFileModificationTime.set(filePath, mtime);
-
-        return config?.default ?? config;
-    }
-
-    const config = (await import(fileURL.href)).default;
-
-    importedConfigFileModificationTime.set(filePath, mtime);
-
-    return config;
-}
 
 /**
  * Determines which config file to use. This is determined by seeing if an
  * override config file was passed, 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`.
+ *
+ * This function is used primarily by the `--inspect-config` option. For now,
+ * we will maintain the existing behavior, which is to search up from the cwd.
  * @param {ESLintOptions} options The ESLint instance options.
- * @param {boolean} hasUnstableTSConfigFlag `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
- * @returns {Promise<{configFilePath:string|undefined;basePath:string;error:Error|null}>} Location information for
+ * @param {boolean} allowTS `true` if the `unstable_ts_config` flag is enabled, `false` if it's not.
+ * @returns {Promise<{configFilePath:string|undefined;basePath:string}>} Location information for
  *      the config file.
  */
-async function locateConfigFileToUse({ configFile, cwd }, hasUnstableTSConfigFlag) {
-
-    // determine where to load config file from
-    let configFilePath;
-    let basePath = cwd;
-    let error = null;
-
-    if (typeof configFile === "string") {
-        debug(`Override config file path is ${configFile}`);
-        configFilePath = path.resolve(cwd, configFile);
-    } else if (configFile !== false) {
-        debug("Searching for eslint.config.js");
-        configFilePath = await findFlatConfigFile(cwd, hasUnstableTSConfigFlag);
-
-        if (configFilePath) {
-            basePath = path.resolve(path.dirname(configFilePath));
-        } else {
-            error = new Error("Could not find config file.");
-            error.messageTemplate = "config-file-missing";
-        }
+async function locateConfigFileToUse({ configFile, cwd }, allowTS) {
 
+    const configLoader = new ConfigLoader({
+        cwd,
+        allowTS,
+        configFile
+    });
+
+    const configFilePath = await configLoader.findConfigFileForPath(path.join(cwd, "__placeholder__.js"));
+
+    if (!configFilePath) {
+        throw new Error("No ESLint configuration file was found.");
     }
 
     return {
         configFilePath,
-        basePath,
-        error
+        basePath: configFile ? cwd : path.dirname(configFilePath)
     };
-
-}
-
-/**
- * Calculates the config array for this run based on inputs.
- * @param {ESLint} eslint The instance to create the config array for.
- * @param {ESLintOptions} options The ESLint instance options.
- * @returns {Promise<typeof FlatConfigArray>} The config array for `eslint``.
- */
-async function calculateConfigArray(eslint, {
-    cwd,
-    baseConfig,
-    overrideConfig,
-    configFile,
-    ignore: shouldIgnore,
-    ignorePatterns
-}) {
-
-    // check for cached instance
-    const slots = privateMembers.get(eslint);
-
-    if (slots.configs) {
-        return slots.configs;
-    }
-
-    const hasUnstableTSConfigFlag = eslint.hasFlag("unstable_ts_config");
-
-    const { configFilePath, basePath, error } = await locateConfigFileToUse({ configFile, cwd }, hasUnstableTSConfigFlag);
-
-    // config file is required to calculate config
-    if (error) {
-        throw error;
-    }
-
-    const configs = new FlatConfigArray(baseConfig || [], { basePath, shouldIgnore });
-
-    // load config file
-    if (configFilePath) {
-        const fileConfig = await loadFlatConfigFile(configFilePath, hasUnstableTSConfigFlag);
-
-        if (Array.isArray(fileConfig)) {
-            configs.push(...fileConfig);
-        } else {
-            configs.push(fileConfig);
-        }
-    }
-
-    // add in any configured defaults
-    configs.push(...slots.defaultConfigs);
-
-    // append command line ignore patterns
-    if (ignorePatterns && ignorePatterns.length > 0) {
-
-        let relativeIgnorePatterns;
-
-        /*
-         * If the config file basePath is different than the cwd, then
-         * the ignore patterns won't work correctly. Here, we adjust the
-         * ignore pattern to include the correct relative path. Patterns
-         * passed as `ignorePatterns` are relative to the cwd, whereas
-         * the config file basePath can be an ancestor of the cwd.
-         */
-        if (basePath === cwd) {
-            relativeIgnorePatterns = ignorePatterns;
-        } else {
-
-            // In minimatch patterns, only `/` can be used as path separator
-            const relativeIgnorePath = path.relative(basePath, cwd).replaceAll(path.sep, "/");
-
-            relativeIgnorePatterns = ignorePatterns.map(pattern => {
-                const negated = pattern.startsWith("!");
-                const basePattern = negated ? pattern.slice(1) : pattern;
-
-                return (negated ? "!" : "") +
-                path.posix.join(relativeIgnorePath, basePattern);
-            });
-        }
-
-        /*
-         * Ignore patterns are added to the end of the config array
-         * so they can override default ignores.
-         */
-        configs.push({
-            ignores: relativeIgnorePatterns
-        });
-    }
-
-    if (overrideConfig) {
-        if (Array.isArray(overrideConfig)) {
-            configs.push(...overrideConfig);
-        } else {
-            configs.push(overrideConfig);
-        }
-    }
-
-    await configs.normalize();
-
-    // cache the config array for this instance
-    slots.configs = configs;
-
-    return configs;
 }
 
 /**
@@ -678,6 +433,12 @@ class ESLint {
      */
     static configType = "flat";
 
+    /**
+     * The loader to use for finding config files.
+     * @type {ConfigLoader|LegacyConfigLoader}
+     */
+    #configLoader;
+
     /**
      * Creates a new instance of the main ESLint API.
      * @param {ESLintOptions} options The options for this instance.
@@ -701,15 +462,34 @@ class ESLint {
             ? new LintResultCache(cacheFilePath, processedOptions.cacheStrategy)
             : null;
 
+        const configLoaderOptions = {
+            cwd: processedOptions.cwd,
+            baseConfig: processedOptions.baseConfig,
+            overrideConfig: processedOptions.overrideConfig,
+            configFile: processedOptions.configFile,
+            ignoreEnabled: processedOptions.ignore,
+            ignorePatterns: processedOptions.ignorePatterns,
+            defaultConfigs,
+            allowTS: processedOptions.flags.includes("unstable_ts_config")
+        };
+
+        this.#configLoader = processedOptions.flags.includes("unstable_config_lookup_from_file")
+            ? new ConfigLoader(configLoaderOptions)
+            : new LegacyConfigLoader(configLoaderOptions);
+
+        debug(`Using config loader ${this.#configLoader.constructor.name}`);
+
         privateMembers.set(this, {
             options: processedOptions,
             linter,
             cacheFilePath,
             lintResultCache,
             defaultConfigs,
-            configs: null
+            configs: null,
+            configLoader: this.#configLoader
         });
 
+
         /**
          * If additional plugins are passed in, add that to the default
          * configs for this instance.
@@ -744,6 +524,15 @@ class ESLint {
         return version;
     }
 
+    /**
+     * The default configuration that ESLint uses internally. This is provided for tooling that wants to calculate configurations using the same defaults as ESLint.
+     * Keep in mind that the default configuration may change from version to version, so you shouldn't rely on any particular keys or values to be present.
+     * @type {ConfigArray}
+     */
+    static get defaultConfig() {
+        return defaultConfig;
+    }
+
     /**
      * Outputs fixes from the given results to files.
      * @param {LintResult[]} results The lint results.
@@ -813,20 +602,10 @@ class ESLint {
 
         const resultRules = new Map();
         const {
-            configs,
+            configLoader,
             options: { cwd }
         } = privateMembers.get(this);
 
-        /*
-         * We can only accurately return rules meta information for linting results if the
-         * results were created by this instance. Otherwise, the necessary rules data is
-         * not available. So if the config array doesn't already exist, just throw an error
-         * to let the user know we can't do anything here.
-         */
-        if (!configs) {
-            throw createExtraneousResultsError();
-        }
-
         for (const result of results) {
 
             /*
@@ -845,6 +624,14 @@ class ESLint {
                  * All of the plugin and rule information is contained within the
                  * calculated config for the given file.
                  */
+                let configs;
+
+                try {
+                    configs = configLoader.getCachedConfigArrayForFile(filePath);
+                } catch {
+                    throw createExtraneousResultsError();
+                }
+
                 const config = configs.getConfig(filePath);
 
                 if (!config) {
@@ -919,7 +706,6 @@ class ESLint {
 
         debug(`Using file patterns: ${normalizedPatterns}`);
 
-        const configs = await calculateConfigArray(this, eslintOptions);
         const {
             allowInlineConfig,
             cache,
@@ -955,7 +741,7 @@ class ESLint {
             patterns: normalizedPatterns,
             cwd,
             globInputPaths,
-            configs,
+            configLoader: this.#configLoader,
             errorOnUnmatchedPattern
         });
         const controller = new AbortController();
@@ -972,8 +758,9 @@ class ESLint {
          */
         const results = await Promise.all(
 
-            filePaths.map(filePath => {
+            filePaths.map(async filePath => {
 
+                const configs = await this.#configLoader.loadConfigArrayForFile(filePath);
                 const config = configs.getConfig(filePath);
 
                 /*
@@ -1111,7 +898,6 @@ class ESLint {
             linter,
             options: eslintOptions
         } = privateMembers.get(this);
-        const configs = await calculateConfigArray(this, eslintOptions);
         const {
             allowInlineConfig,
             cwd,
@@ -1125,21 +911,21 @@ class ESLint {
         const startTime = Date.now();
         const fixTypesSet = fixTypes ? new Set(fixTypes) : null;
         const resolvedFilename = path.resolve(cwd, filePath || "__placeholder__.js");
-        const config = configs.getConfig(resolvedFilename);
-
-        const fixer = getFixerForFixTypes(fix, fixTypesSet, config);
+        const configs = await this.#configLoader.loadConfigArrayForFile(resolvedFilename);
+        const configStatus = configs?.getConfigStatus(resolvedFilename) ?? "unconfigured";
 
         // Clear the last used config arrays.
-        if (resolvedFilename && await this.isPathIgnored(resolvedFilename)) {
+        if (resolvedFilename && configStatus !== "matched") {
             const shouldWarnIgnored = typeof warnIgnored === "boolean" ? warnIgnored : constructorWarnIgnored;
 
             if (shouldWarnIgnored) {
-                const configStatus = configs.getConfigStatus(resolvedFilename);
-
                 results.push(createIgnoreResult(resolvedFilename, cwd, configStatus));
             }
         } else {
 
+            const config = configs.getConfig(resolvedFilename);
+            const fixer = getFixerForFixTypes(fix, fixTypesSet, config);
+
             // Do lint.
             results.push(verifyText({
                 text: code,
@@ -1271,7 +1057,14 @@ class ESLint {
         }
         const options = privateMembers.get(this).options;
         const absolutePath = path.resolve(options.cwd, filePath);
-        const configs = await calculateConfigArray(this, options);
+        const configs = await this.#configLoader.loadConfigArrayForFile(absolutePath);
+
+        if (!configs) {
+            const error = new Error("Could not find config file.");
+
+            error.messageTemplate = "config-file-missing";
+            throw error;
+        }
 
         return configs.getConfig(absolutePath);
     }
@@ -1279,14 +1072,22 @@ class ESLint {
     /**
      * Finds the config file being used by this instance based on the options
      * passed to the constructor.
+     * @param {string} [filePath] The path of the file to find the config file for.
      * @returns {Promise<string|undefined>} The path to the config file being used or
      *      `undefined` if no config file is being used.
      */
-    async findConfigFile() {
+    findConfigFile(filePath) {
         const options = privateMembers.get(this).options;
-        const { configFilePath } = await locateConfigFileToUse(options, this.hasFlag("unstable_ts_config"));
 
-        return configFilePath;
+        /*
+         * Because the new config lookup scheme skips the current directory
+         * and looks into the parent directories, we need to use a placeholder
+         * directory to ensure the file in cwd is checked.
+         */
+        const fakeCwd = path.join(options.cwd, "__placeholder__");
+
+        return this.#configLoader.findConfigFileForPath(filePath ?? fakeCwd)
+            .catch(() => void 0);
     }
 
     /**

package/lib/languages/js/index.js

@@ -12,6 +12,7 @@
 const { SourceCode } = require("./source-code");
 const createDebug = require("debug");
 const astUtils = require("../../shared/ast-utils");
+const espree = require("espree");
 const eslintScope = require("eslint-scope");
 const evk = require("eslint-visitor-keys");
 const { validateLanguageOptions } = require("./validate-language-options");
@@ -69,6 +70,13 @@ module.exports = {
     nodeTypeKey: "type",
     visitorKeys: evk.KEYS,
 
+    defaultLanguageOptions: {
+        sourceType: "module",
+        ecmaVersion: "latest",
+        parser: espree,
+        parserOptions: {}
+    },
+
     validateLanguageOptions,
 
     /**

package/lib/linter/linter.js

@@ -1643,29 +1643,26 @@ class Linter {
         const options = normalizeVerifyOptions(providedOptions, config);
         const languageOptions = config.languageOptions;
 
-        languageOptions.ecmaVersion = normalizeEcmaVersionForLanguageOptions(
-            languageOptions.ecmaVersion
-        );
-
-        // double check that there is a parser to avoid mysterious error messages
-        if (!languageOptions.parser) {
-            throw new TypeError(`No parser specified for ${options.filename}`);
-        }
+        if (config.language === jslang) {
+            languageOptions.ecmaVersion = normalizeEcmaVersionForLanguageOptions(
+                languageOptions.ecmaVersion
+            );
 
-        // Espree expects this information to be passed in
-        if (isEspree(languageOptions.parser)) {
-            const parserOptions = languageOptions.parserOptions;
+            // Espree expects this information to be passed in
+            if (isEspree(languageOptions.parser)) {
+                const parserOptions = languageOptions.parserOptions;
 
-            if (languageOptions.sourceType) {
+                if (languageOptions.sourceType) {
 
-                parserOptions.sourceType = languageOptions.sourceType;
+                    parserOptions.sourceType = languageOptions.sourceType;
 
-                if (
-                    parserOptions.sourceType === "module" &&
-                    parserOptions.ecmaFeatures &&
-                    parserOptions.ecmaFeatures.globalReturn
-                ) {
-                    parserOptions.ecmaFeatures.globalReturn = false;
+                    if (
+                        parserOptions.sourceType === "module" &&
+                        parserOptions.ecmaFeatures &&
+                        parserOptions.ecmaFeatures.globalReturn
+                    ) {
+                        parserOptions.ecmaFeatures.globalReturn = false;
+                    }
                 }
             }
         }