eslint 8.47.0 → 8.57.0

package/lib/config/flat-config-schema.js

@@ -5,6 +5,17 @@
 
 "use strict";
 
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+/*
+ * Note: This can be removed in ESLint v9 because structuredClone is available globally
+ * starting in Node.js v17.
+ */
+const structuredClone = require("@ungap/structured-clone").default;
+const { normalizeSeverityToNumber } = require("../shared/severity");
+
 //-----------------------------------------------------------------------------
 // Type Definitions
 //-----------------------------------------------------------------------------
@@ -42,6 +53,15 @@ function isNonNullObject(value) {
     return typeof value === "object" && value !== null;
 }
 
+/**
+ * Check if a value is a non-null non-array object.
+ * @param {any} value The value to check.
+ * @returns {boolean} `true` if the value is a non-null non-array object.
+ */
+function isNonArrayObject(value) {
+    return isNonNullObject(value) && !Array.isArray(value);
+}
+
 /**
  * Check if a value is undefined.
  * @param {any} value The value to check.
@@ -52,19 +72,27 @@ function isUndefined(value) {
 }
 
 /**
- * Deeply merges two objects.
+ * Deeply merges two non-array objects.
  * @param {Object} first The base object.
  * @param {Object} second The overrides object.
+ * @param {Map<string, Map<string, Object>>} [mergeMap] Maps the combination of first and second arguments to a merged result.
  * @returns {Object} An object with properties from both first and second.
  */
-function deepMerge(first = {}, second = {}) {
+function deepMerge(first, second, mergeMap = new Map()) {
 
-    /*
-     * If the second value is an array, just return it. We don't merge
-     * arrays because order matters and we can't know the correct order.
-     */
-    if (Array.isArray(second)) {
-        return second;
+    let secondMergeMap = mergeMap.get(first);
+
+    if (secondMergeMap) {
+        const result = secondMergeMap.get(second);
+
+        if (result) {
+
+            // If this combination of first and second arguments has been already visited, return the previously created result.
+            return result;
+        }
+    } else {
+        secondMergeMap = new Map();
+        mergeMap.set(first, secondMergeMap);
     }
 
     /*
@@ -78,27 +106,25 @@ function deepMerge(first = {}, second = {}) {
         ...second
     };
 
+    delete result.__proto__; // eslint-disable-line no-proto -- don't merge own property "__proto__"
+
+    // Store the pending result for this combination of first and second arguments.
+    secondMergeMap.set(second, result);
+
     for (const key of Object.keys(second)) {
 
         // avoid hairy edge case
-        if (key === "__proto__") {
+        if (key === "__proto__" || !Object.prototype.propertyIsEnumerable.call(first, key)) {
             continue;
         }
 
         const firstValue = first[key];
         const secondValue = second[key];
 
-        if (isNonNullObject(firstValue)) {
-            result[key] = deepMerge(firstValue, secondValue);
-        } else if (isUndefined(firstValue)) {
-            if (isNonNullObject(secondValue)) {
-                result[key] = deepMerge(
-                    Array.isArray(secondValue) ? [] : {},
-                    secondValue
-                );
-            } else if (!isUndefined(secondValue)) {
-                result[key] = secondValue;
-            }
+        if (isNonArrayObject(firstValue) && isNonArrayObject(secondValue)) {
+            result[key] = deepMerge(firstValue, secondValue, mergeMap);
+        } else if (isUndefined(secondValue)) {
+            result[key] = firstValue;
         }
     }
 
@@ -119,7 +145,7 @@ function normalizeRuleOptions(ruleOptions) {
         : [ruleOptions];
 
     finalOptions[0] = ruleSeverities.get(finalOptions[0]);
-    return finalOptions;
+    return structuredClone(finalOptions);
 }
 
 //-----------------------------------------------------------------------------
@@ -179,9 +205,7 @@ class InvalidRuleSeverityError extends Error {
  * @throws {InvalidRuleSeverityError} If the value isn't a valid rule severity.
  */
 function assertIsRuleSeverity(ruleId, value) {
-    const severity = typeof value === "string"
-        ? ruleSeverities.get(value.toLowerCase())
-        : ruleSeverities.get(value);
+    const severity = ruleSeverities.get(value);
 
     if (typeof severity === "undefined") {
         throw new InvalidRuleSeverityError(ruleId, value);
@@ -254,6 +278,26 @@ const booleanSchema = {
     validate: "boolean"
 };
 
+const ALLOWED_SEVERITIES = new Set(["error", "warn", "off", 2, 1, 0]);
+
+/** @type {ObjectPropertySchema} */
+const disableDirectiveSeveritySchema = {
+    merge(first, second) {
+        const value = second === void 0 ? first : second;
+
+        if (typeof value === "boolean") {
+            return value ? "warn" : "off";
+        }
+
+        return normalizeSeverityToNumber(value);
+    },
+    validate(value) {
+        if (!(ALLOWED_SEVERITIES.has(value) || typeof value === "boolean")) {
+            throw new TypeError("Expected one of: \"error\", \"warn\", \"off\", 0, 1, 2, or a boolean.");
+        }
+    }
+};
+
 /** @type {ObjectPropertySchema} */
 const deepObjectAssignSchema = {
     merge(first = {}, second = {}) {
@@ -380,48 +424,57 @@ const rulesSchema = {
             ...second
         };
 
-        for (const ruleId of Object.keys(result)) {
-
-            // avoid hairy edge case
-            if (ruleId === "__proto__") {
-
-                /* eslint-disable-next-line no-proto -- Though deprecated, may still be present */
-                delete result.__proto__;
-                continue;
-            }
-
-            result[ruleId] = normalizeRuleOptions(result[ruleId]);
 
-            /*
-             * If either rule config is missing, then the correct
-             * config is already present and we just need to normalize
-             * the severity.
-             */
-            if (!(ruleId in first) || !(ruleId in second)) {
-                continue;
-            }
-
-            const firstRuleOptions = normalizeRuleOptions(first[ruleId]);
-            const secondRuleOptions = normalizeRuleOptions(second[ruleId]);
+        for (const ruleId of Object.keys(result)) {
 
-            /*
-             * If the second rule config only has a severity (length of 1),
-             * then use that severity and keep the rest of the options from
-             * the first rule config.
-             */
-            if (secondRuleOptions.length === 1) {
-                result[ruleId] = [secondRuleOptions[0], ...firstRuleOptions.slice(1)];
-                continue;
+            try {
+
+                // avoid hairy edge case
+                if (ruleId === "__proto__") {
+
+                    /* eslint-disable-next-line no-proto -- Though deprecated, may still be present */
+                    delete result.__proto__;
+                    continue;
+                }
+
+                result[ruleId] = normalizeRuleOptions(result[ruleId]);
+
+                /*
+                 * If either rule config is missing, then the correct
+                 * config is already present and we just need to normalize
+                 * the severity.
+                 */
+                if (!(ruleId in first) || !(ruleId in second)) {
+                    continue;
+                }
+
+                const firstRuleOptions = normalizeRuleOptions(first[ruleId]);
+                const secondRuleOptions = normalizeRuleOptions(second[ruleId]);
+
+                /*
+                 * If the second rule config only has a severity (length of 1),
+                 * then use that severity and keep the rest of the options from
+                 * the first rule config.
+                 */
+                if (secondRuleOptions.length === 1) {
+                    result[ruleId] = [secondRuleOptions[0], ...firstRuleOptions.slice(1)];
+                    continue;
+                }
+
+                /*
+                 * In any other situation, then the second rule config takes
+                 * precedence. That means the value at `result[ruleId]` is
+                 * already correct and no further work is necessary.
+                 */
+            } catch (ex) {
+                throw new Error(`Key "${ruleId}": ${ex.message}`, { cause: ex });
             }
 
-            /*
-             * In any other situation, then the second rule config takes
-             * precedence. That means the value at `result[ruleId]` is
-             * already correct and no further work is necessary.
-             */
         }
 
         return result;
+
+
     },
 
     validate(value) {
@@ -507,7 +560,7 @@ const eslintrcKeys = [
 // Full schema
 //-----------------------------------------------------------------------------
 
-exports.flatConfigSchema = {
+const flatConfigSchema = {
 
     // eslintrc-style keys that should always error
     ...Object.fromEntries(eslintrcKeys.map(key => [key, createEslintrcErrorSchema(key)])),
@@ -517,7 +570,7 @@ exports.flatConfigSchema = {
     linterOptions: {
         schema: {
             noInlineConfig: booleanSchema,
-            reportUnusedDisableDirectives: booleanSchema
+            reportUnusedDisableDirectives: disableDirectiveSeveritySchema
         }
     },
     languageOptions: {
@@ -533,3 +586,13 @@ exports.flatConfigSchema = {
     plugins: pluginsSchema,
     rules: rulesSchema
 };
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+module.exports = {
+    flatConfigSchema,
+    assertIsRuleSeverity,
+    assertIsRuleOptions
+};

package/lib/config/rule-validator.js

@@ -9,7 +9,8 @@
 // Requirements
 //-----------------------------------------------------------------------------
 
-const ajv = require("../shared/ajv")();
+const ajvImport = require("../shared/ajv");
+const ajv = ajvImport();
 const {
     parseRuleId,
     getRuleFromConfig,

package/lib/eslint/eslint-helpers.js

@@ -594,9 +594,9 @@ function createIgnoreResult(filePath, baseDir) {
     const isInNodeModules = baseDir && path.dirname(path.relative(baseDir, filePath)).split(path.sep).includes("node_modules");
 
     if (isInNodeModules) {
-        message = "File ignored by default because it is located under the node_modules directory. Use ignore pattern \"!**/node_modules/\" to override.";
+        message = "File ignored by default because it is located under the node_modules directory. Use ignore pattern \"!**/node_modules/\" to disable file ignore settings or use \"--no-warn-ignored\" to suppress this warning.";
     } else {
-        message = "File ignored because of a matching ignore pattern. Use \"--no-ignore\" to override.";
+        message = "File ignored because of a matching ignore pattern. Use \"--no-ignore\" to disable file ignore settings or use \"--no-warn-ignored\" to suppress this warning.";
     }
 
     return {
@@ -675,7 +675,7 @@ function processOptions({
     overrideConfig = null,
     overrideConfigFile = null,
     plugins = {},
-    reportUnusedDisableDirectives = null, // ← should be null by default because if it's a string then it overrides the 'reportUnusedDisableDirectives' setting in config files. And we cannot use `overrideConfig.reportUnusedDisableDirectives` instead because we cannot configure the `error` severity with that.
+    warnIgnored = true,
     ...unknownOptions
 }) {
     const errors = [];
@@ -719,6 +719,9 @@ function processOptions({
         if (unknownOptionKeys.includes("rulePaths")) {
             errors.push("'rulePaths' has been removed. Please define your rules using plugins.");
         }
+        if (unknownOptionKeys.includes("reportUnusedDisableDirectives")) {
+            errors.push("'reportUnusedDisableDirectives' has been removed. Please use the 'overrideConfig.linterOptions.reportUnusedDisableDirectives' option instead.");
+        }
     }
     if (typeof allowInlineConfig !== "boolean") {
         errors.push("'allowInlineConfig' must be a boolean.");
@@ -773,13 +776,8 @@ function processOptions({
     if (Array.isArray(plugins)) {
         errors.push("'plugins' doesn't add plugins to configuration to load. Please use the 'overrideConfig.plugins' option instead.");
     }
-    if (
-        reportUnusedDisableDirectives !== "error" &&
-        reportUnusedDisableDirectives !== "warn" &&
-        reportUnusedDisableDirectives !== "off" &&
-        reportUnusedDisableDirectives !== null
-    ) {
-        errors.push("'reportUnusedDisableDirectives' must be any of \"error\", \"warn\", \"off\", and null.");
+    if (typeof warnIgnored !== "boolean") {
+        errors.push("'warnIgnored' must be a boolean.");
     }
     if (errors.length > 0) {
         throw new ESLintInvalidOptionsError(errors);
@@ -802,7 +800,7 @@ function processOptions({
         globInputPaths,
         ignore,
         ignorePatterns,
-        reportUnusedDisableDirectives
+        warnIgnored
     };
 }
 

package/lib/eslint/eslint.js

@@ -682,6 +682,13 @@ class ESLint {
     }
 }
 
+/**
+ * The type of configuration used by this class.
+ * @type {string}
+ * @static
+ */
+ESLint.configType = "eslintrc";
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------

package/lib/eslint/flat-eslint.js

@@ -11,6 +11,7 @@
 
 // Note: Node.js 12 does not support fs/promises.
 const fs = require("fs").promises;
+const { existsSync } = require("fs");
 const path = require("path");
 const findUp = require("find-up");
 const { version } = require("../../package.json");
@@ -83,14 +84,18 @@ const LintResultCache = require("../cli-engine/lint-result-cache");
  *      doesn't do any config file lookup when `true`; considered to be a config filename
  *      when a string.
  * @property {Record<string,Plugin>} [plugins] An array of plugin implementations.
- * @property {"error" | "warn" | "off"} [reportUnusedDisableDirectives] the severity to report unused eslint-disable directives.
+ * @property {boolean} warnIgnored Show warnings when the file list includes ignored files
  */
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-const FLAT_CONFIG_FILENAME = "eslint.config.js";
+const FLAT_CONFIG_FILENAMES = [
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs"
+];
 const debug = require("debug")("eslint:flat-eslint");
 const removedFormatters = new Set(["table", "codeframe"]);
 const privateMembers = new WeakMap();
@@ -247,7 +252,7 @@ function compareResultsByFilePath(a, b) {
  */
 function findFlatConfigFile(cwd) {
     return findUp(
-        FLAT_CONFIG_FILENAME,
+        FLAT_CONFIG_FILENAMES,
         { cwd }
     );
 }
@@ -447,7 +452,6 @@ async function calculateConfigArray(eslint, {
  * @param {FlatConfigArray} config.configs The config.
  * @param {boolean} config.fix If `true` then it does fix.
  * @param {boolean} config.allowInlineConfig If `true` then it uses directive comments.
- * @param {boolean} config.reportUnusedDisableDirectives If `true` then it reports unused `eslint-disable` comments.
  * @param {Linter} config.linter The linter instance to verify.
  * @returns {LintResult} The result of linting.
  * @private
@@ -459,7 +463,6 @@ function verifyText({
     configs,
     fix,
     allowInlineConfig,
-    reportUnusedDisableDirectives,
     linter
 }) {
     const filePath = providedFilePath || "<text>";
@@ -479,7 +482,6 @@ function verifyText({
             allowInlineConfig,
             filename: filePathToVerify,
             fix,
-            reportUnusedDisableDirectives,
 
             /**
              * Check if the linter should adopt a given code block or not.
@@ -747,9 +749,9 @@ class FlatESLint {
             cwd,
             fix,
             fixTypes,
-            reportUnusedDisableDirectives,
             globInputPaths,
-            errorOnUnmatchedPattern
+            errorOnUnmatchedPattern,
+            warnIgnored
         } = eslintOptions;
         const startTime = Date.now();
         const fixTypesSet = fixTypes ? new Set(fixTypes) : null;
@@ -764,7 +766,7 @@ class FlatESLint {
                 const errorCode = error && error.code;
 
                 // Ignore errors when no such file exists or file system is read only (and cache file does not exist)
-                if (errorCode !== "ENOENT" && !(errorCode === "EROFS" && !(await fs.exists(cacheFilePath)))) {
+                if (errorCode !== "ENOENT" && !(errorCode === "EROFS" && !existsSync(cacheFilePath))) {
                     throw error;
                 }
             }
@@ -795,7 +797,11 @@ class FlatESLint {
                  * pattern, then notify the user.
                  */
                 if (ignored) {
-                    return createIgnoreResult(filePath, cwd);
+                    if (warnIgnored) {
+                        return createIgnoreResult(filePath, cwd);
+                    }
+
+                    return void 0;
                 }
 
                 const config = configs.getConfig(filePath);
@@ -852,7 +858,6 @@ class FlatESLint {
                             cwd,
                             fix: fixer,
                             allowInlineConfig,
-                            reportUnusedDisableDirectives,
                             linter
                         });
 
@@ -908,7 +913,7 @@ class FlatESLint {
 
         const {
             filePath,
-            warnIgnored = false,
+            warnIgnored,
             ...unknownOptions
         } = options || {};
 
@@ -922,7 +927,7 @@ class FlatESLint {
             throw new Error("'options.filePath' must be a non-empty string or undefined");
         }
 
-        if (typeof warnIgnored !== "boolean") {
+        if (typeof warnIgnored !== "boolean" && typeof warnIgnored !== "undefined") {
             throw new Error("'options.warnIgnored' must be a boolean or undefined");
         }
 
@@ -937,7 +942,7 @@ class FlatESLint {
             allowInlineConfig,
             cwd,
             fix,
-            reportUnusedDisableDirectives
+            warnIgnored: constructorWarnIgnored
         } = eslintOptions;
         const results = [];
         const startTime = Date.now();
@@ -945,7 +950,9 @@ class FlatESLint {
 
         // Clear the last used config arrays.
         if (resolvedFilename && await this.isPathIgnored(resolvedFilename)) {
-            if (warnIgnored) {
+            const shouldWarnIgnored = typeof warnIgnored === "boolean" ? warnIgnored : constructorWarnIgnored;
+
+            if (shouldWarnIgnored) {
                 results.push(createIgnoreResult(resolvedFilename, cwd));
             }
         } else {
@@ -958,7 +965,6 @@ class FlatESLint {
                 cwd,
                 fix,
                 allowInlineConfig,
-                reportUnusedDisableDirectives,
                 linter
             }));
         }
@@ -1110,11 +1116,20 @@ class FlatESLint {
     }
 }
 
+/**
+ * The type of configuration used by this class.
+ * @type {string}
+ * @static
+ */
+FlatESLint.configType = "flat";
+
 /**
  * Returns whether flat config should be used.
+ * @param {Object} [options] The options for this function.
+ * @param {string} [options.cwd] The current working directory.
  * @returns {Promise<boolean>} Whether flat config should be used.
  */
-async function shouldUseFlatConfig() {
+async function shouldUseFlatConfig({ cwd = process.cwd() } = {}) {
     switch (process.env.ESLINT_USE_FLAT_CONFIG) {
         case "true":
             return true;
@@ -1126,7 +1141,7 @@ async function shouldUseFlatConfig() {
              * If neither explicitly enabled nor disabled, then use the presence
              * of a flat config file to determine enablement.
              */
-            return !!(await findFlatConfigFile(process.cwd()));
+            return !!(await findFlatConfigFile(cwd));
     }
 }