eslint 9.22.0 → 9.24.0

package/lib/config/config.js

@@ -22,12 +22,12 @@ const { ObjectSchema } = require("@eslint/config-array");
 const ruleValidator = new RuleValidator();
 
 const severities = new Map([
-    [0, 0],
-    [1, 1],
-    [2, 2],
-    ["off", 0],
-    ["warn", 1],
-    ["error", 2]
+	[0, 0],
+	[1, 1],
+	[2, 2],
+	["off", 0],
+	["warn", 1],
+	["error", 2],
 ]);
 
 /**
@@ -37,12 +37,12 @@ const severities = new Map([
  *      name.
  */
 function splitPluginIdentifier(identifier) {
-    const parts = identifier.split("/");
+	const parts = identifier.split("/");
 
-    return {
-        objectName: parts.pop(),
-        pluginName: parts.join("/")
-    };
+	return {
+		objectName: parts.pop(),
+		pluginName: parts.join("/"),
+	};
 }
 
 /**
@@ -52,36 +52,34 @@ function splitPluginIdentifier(identifier) {
  *      is no name.
  */
 function getObjectId(object) {
+	// first check old-style name
+	let name = object.name;
 
-    // first check old-style name
-    let name = object.name;
+	if (!name) {
+		if (!object.meta) {
+			return null;
+		}
 
-    if (!name) {
+		name = object.meta.name;
 
-        if (!object.meta) {
-            return null;
-        }
+		if (!name) {
+			return null;
+		}
+	}
 
-        name = object.meta.name;
+	// now check for old-style version
+	let version = object.version;
 
-        if (!name) {
-            return null;
-        }
-    }
+	if (!version) {
+		version = object.meta && object.meta.version;
+	}
 
-    // now check for old-style version
-    let version = object.version;
+	// if there's a version then append that
+	if (version) {
+		return `${name}@${version}`;
+	}
 
-    if (!version) {
-        version = object.meta && object.meta.version;
-    }
-
-    // if there's a version then append that
-    if (version) {
-        return `${name}@${version}`;
-    }
-
-    return name;
+	return name;
 }
 
 /**
@@ -93,40 +91,39 @@ function getObjectId(object) {
  * @throws {TypeError} If a function is found in the languageOptions.
  */
 function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
+	const result = {};
 
-    const result = {};
-
-    for (const [key, value] of Object.entries(languageOptions)) {
-        if (value) {
-            if (typeof value === "object") {
-                const name = getObjectId(value);
+	for (const [key, value] of Object.entries(languageOptions)) {
+		if (value) {
+			if (typeof value === "object") {
+				const name = getObjectId(value);
 
-                if (name && hasMethod(value)) {
-                    result[key] = name;
-                } else {
-                    result[key] = languageOptionsToJSON(value, key);
-                }
-                continue;
-            }
+				if (name && hasMethod(value)) {
+					result[key] = name;
+				} else {
+					result[key] = languageOptionsToJSON(value, key);
+				}
+				continue;
+			}
 
-            if (typeof value === "function") {
-                const error = new TypeError(`Cannot serialize key "${key}" in ${objectKey}: Function values are not supported.`);
+			if (typeof value === "function") {
+				const error = new TypeError(
+					`Cannot serialize key "${key}" in ${objectKey}: Function values are not supported.`,
+				);
 
-                error.messageTemplate = "config-serialize-function";
-                error.messageData = { key, objectKey };
+				error.messageTemplate = "config-serialize-function";
+				error.messageData = { key, objectKey };
 
-                throw error;
-            }
+				throw error;
+			}
+		}
 
-        }
+		result[key] = value;
+	}
 
-        result[key] = value;
-    }
-
-    return result;
+	return result;
 }
 
-
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
@@ -135,168 +132,197 @@ function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
  * Represents a normalized configuration object.
  */
 class Config {
-
-    /**
-     * The name to use for the language when serializing to JSON.
-     * @type {string|undefined}
-     */
-    #languageName;
-
-    /**
-     * The name to use for the processor when serializing to JSON.
-     * @type {string|undefined}
-     */
-    #processorName;
-
-    /**
-     * Creates a new instance.
-     * @param {Object} config The configuration object.
-     */
-    constructor(config) {
-
-        const { plugins, language, languageOptions, processor, ...otherKeys } = config;
-
-        // Validate config object
-        const schema = new ObjectSchema(flatConfigSchema);
-
-        schema.validate(config);
-
-        // first, copy all the other keys over
-        Object.assign(this, otherKeys);
-
-        // ensure that a language is specified
-        if (!language) {
-            throw new TypeError("Key 'language' is required.");
-        }
-
-        // copy the rest over
-        this.plugins = plugins;
-        this.language = language;
-
-        // Check language value
-        const { pluginName: languagePluginName, objectName: localLanguageName } = splitPluginIdentifier(language);
-
-        this.#languageName = language;
-
-        if (!plugins || !plugins[languagePluginName] || !plugins[languagePluginName].languages || !plugins[languagePluginName].languages[localLanguageName]) {
-            throw new TypeError(`Key "language": Could not find "${localLanguageName}" in plugin "${languagePluginName}".`);
-        }
-
-        this.language = plugins[languagePluginName].languages[localLanguageName];
-
-        if (this.language.defaultLanguageOptions ?? languageOptions) {
-            this.languageOptions = flatConfigSchema.languageOptions.merge(
-                this.language.defaultLanguageOptions,
-                languageOptions
-            );
-        } else {
-            this.languageOptions = {};
-        }
-
-        // Validate language options
-        try {
-            this.language.validateLanguageOptions(this.languageOptions);
-        } catch (error) {
-            throw new TypeError(`Key "languageOptions": ${error.message}`, { cause: error });
-        }
-
-        // Normalize language options if necessary
-        if (this.language.normalizeLanguageOptions) {
-            this.languageOptions = this.language.normalizeLanguageOptions(this.languageOptions);
-        }
-
-        // Check processor value
-        if (processor) {
-            this.processor = processor;
-
-            if (typeof processor === "string") {
-                const { pluginName, objectName: localProcessorName } = splitPluginIdentifier(processor);
-
-                this.#processorName = processor;
-
-                if (!plugins || !plugins[pluginName] || !plugins[pluginName].processors || !plugins[pluginName].processors[localProcessorName]) {
-                    throw new TypeError(`Key "processor": Could not find "${localProcessorName}" in plugin "${pluginName}".`);
-                }
-
-                this.processor = plugins[pluginName].processors[localProcessorName];
-            } else if (typeof processor === "object") {
-                this.#processorName = getObjectId(processor);
-                this.processor = processor;
-            } else {
-                throw new TypeError("Key 'processor' must be a string or an object.");
-            }
-        }
-
-        // Process the rules
-        if (this.rules) {
-            this.#normalizeRulesConfig();
-            ruleValidator.validate(this);
-        }
-    }
-
-    /**
-     * Converts the configuration to a JSON representation.
-     * @returns {Record<string, any>} The JSON representation of the configuration.
-     * @throws {Error} If the configuration cannot be serialized.
-     */
-    toJSON() {
-
-        if (this.processor && !this.#processorName) {
-            throw new Error("Could not serialize processor object (missing 'meta' object).");
-        }
-
-        if (!this.#languageName) {
-            throw new Error("Could not serialize language object (missing 'meta' object).");
-        }
-
-        return {
-            ...this,
-            plugins: Object.entries(this.plugins).map(([namespace, plugin]) => {
-
-                const pluginId = getObjectId(plugin);
-
-                if (!pluginId) {
-                    return namespace;
-                }
-
-                return `${namespace}:${pluginId}`;
-            }),
-            language: this.#languageName,
-            languageOptions: languageOptionsToJSON(this.languageOptions),
-            processor: this.#processorName
-        };
-    }
-
-    /**
-     * Normalizes the rules configuration. Ensures that each rule config is
-     * an array and that the severity is a number. Applies meta.defaultOptions.
-     * This function modifies `this.rules`.
-     * @returns {void}
-     */
-    #normalizeRulesConfig() {
-        for (const [ruleId, originalConfig] of Object.entries(this.rules)) {
-
-            // ensure rule config is an array
-            let ruleConfig = Array.isArray(originalConfig)
-                ? originalConfig
-                : [originalConfig];
-
-            // normalize severity
-            ruleConfig[0] = severities.get(ruleConfig[0]);
-
-            const rule = getRuleFromConfig(ruleId, this);
-
-            // apply meta.defaultOptions
-            const slicedOptions = ruleConfig.slice(1);
-            const mergedOptions = deepMergeArrays(rule?.meta?.defaultOptions, slicedOptions);
-
-            if (mergedOptions.length) {
-                ruleConfig = [ruleConfig[0], ...mergedOptions];
-            }
-
-            this.rules[ruleId] = ruleConfig;
-        }
-    }
+	/**
+	 * The name to use for the language when serializing to JSON.
+	 * @type {string|undefined}
+	 */
+	#languageName;
+
+	/**
+	 * The name to use for the processor when serializing to JSON.
+	 * @type {string|undefined}
+	 */
+	#processorName;
+
+	/**
+	 * Creates a new instance.
+	 * @param {Object} config The configuration object.
+	 */
+	constructor(config) {
+		const { plugins, language, languageOptions, processor, ...otherKeys } =
+			config;
+
+		// Validate config object
+		const schema = new ObjectSchema(flatConfigSchema);
+
+		schema.validate(config);
+
+		// first, copy all the other keys over
+		Object.assign(this, otherKeys);
+
+		// ensure that a language is specified
+		if (!language) {
+			throw new TypeError("Key 'language' is required.");
+		}
+
+		// copy the rest over
+		this.plugins = plugins;
+		this.language = language;
+
+		// Check language value
+		const {
+			pluginName: languagePluginName,
+			objectName: localLanguageName,
+		} = splitPluginIdentifier(language);
+
+		this.#languageName = language;
+
+		if (
+			!plugins ||
+			!plugins[languagePluginName] ||
+			!plugins[languagePluginName].languages ||
+			!plugins[languagePluginName].languages[localLanguageName]
+		) {
+			throw new TypeError(
+				`Key "language": Could not find "${localLanguageName}" in plugin "${languagePluginName}".`,
+			);
+		}
+
+		this.language =
+			plugins[languagePluginName].languages[localLanguageName];
+
+		if (this.language.defaultLanguageOptions ?? languageOptions) {
+			this.languageOptions = flatConfigSchema.languageOptions.merge(
+				this.language.defaultLanguageOptions,
+				languageOptions,
+			);
+		} else {
+			this.languageOptions = {};
+		}
+
+		// Validate language options
+		try {
+			this.language.validateLanguageOptions(this.languageOptions);
+		} catch (error) {
+			throw new TypeError(`Key "languageOptions": ${error.message}`, {
+				cause: error,
+			});
+		}
+
+		// Normalize language options if necessary
+		if (this.language.normalizeLanguageOptions) {
+			this.languageOptions = this.language.normalizeLanguageOptions(
+				this.languageOptions,
+			);
+		}
+
+		// Check processor value
+		if (processor) {
+			this.processor = processor;
+
+			if (typeof processor === "string") {
+				const { pluginName, objectName: localProcessorName } =
+					splitPluginIdentifier(processor);
+
+				this.#processorName = processor;
+
+				if (
+					!plugins ||
+					!plugins[pluginName] ||
+					!plugins[pluginName].processors ||
+					!plugins[pluginName].processors[localProcessorName]
+				) {
+					throw new TypeError(
+						`Key "processor": Could not find "${localProcessorName}" in plugin "${pluginName}".`,
+					);
+				}
+
+				this.processor =
+					plugins[pluginName].processors[localProcessorName];
+			} else if (typeof processor === "object") {
+				this.#processorName = getObjectId(processor);
+				this.processor = processor;
+			} else {
+				throw new TypeError(
+					"Key 'processor' must be a string or an object.",
+				);
+			}
+		}
+
+		// Process the rules
+		if (this.rules) {
+			this.#normalizeRulesConfig();
+			ruleValidator.validate(this);
+		}
+	}
+
+	/**
+	 * Converts the configuration to a JSON representation.
+	 * @returns {Record<string, any>} The JSON representation of the configuration.
+	 * @throws {Error} If the configuration cannot be serialized.
+	 */
+	toJSON() {
+		if (this.processor && !this.#processorName) {
+			throw new Error(
+				"Could not serialize processor object (missing 'meta' object).",
+			);
+		}
+
+		if (!this.#languageName) {
+			throw new Error(
+				"Could not serialize language object (missing 'meta' object).",
+			);
+		}
+
+		return {
+			...this,
+			plugins: Object.entries(this.plugins).map(([namespace, plugin]) => {
+				const pluginId = getObjectId(plugin);
+
+				if (!pluginId) {
+					return namespace;
+				}
+
+				return `${namespace}:${pluginId}`;
+			}),
+			language: this.#languageName,
+			languageOptions: languageOptionsToJSON(this.languageOptions),
+			processor: this.#processorName,
+		};
+	}
+
+	/**
+	 * Normalizes the rules configuration. Ensures that each rule config is
+	 * an array and that the severity is a number. Applies meta.defaultOptions.
+	 * This function modifies `this.rules`.
+	 * @returns {void}
+	 */
+	#normalizeRulesConfig() {
+		for (const [ruleId, originalConfig] of Object.entries(this.rules)) {
+			// ensure rule config is an array
+			let ruleConfig = Array.isArray(originalConfig)
+				? originalConfig
+				: [originalConfig];
+
+			// normalize severity
+			ruleConfig[0] = severities.get(ruleConfig[0]);
+
+			const rule = getRuleFromConfig(ruleId, this);
+
+			// apply meta.defaultOptions
+			const slicedOptions = ruleConfig.slice(1);
+			const mergedOptions = deepMergeArrays(
+				rule?.meta?.defaultOptions,
+				slicedOptions,
+			);
+
+			if (mergedOptions.length) {
+				ruleConfig = [ruleConfig[0], ...mergedOptions];
+			}
+
+			this.rules[ruleId] = ruleConfig;
+		}
+	}
 }
 
 module.exports = { Config };

package/lib/config/default-config.js

@@ -15,55 +15,64 @@ const Rules = require("../rules");
 // Helpers
 //-----------------------------------------------------------------------------
 
+const sharedDefaultConfig = [
+	// intentionally empty config to ensure these files are globbed by default
+	{
+		files: ["**/*.js", "**/*.mjs"],
+	},
+	{
+		files: ["**/*.cjs"],
+		languageOptions: {
+			sourceType: "commonjs",
+			ecmaVersion: "latest",
+		},
+	},
+];
+
 exports.defaultConfig = Object.freeze([
-    {
-        plugins: {
-            "@": {
+	{
+		plugins: {
+			"@": {
+				languages: {
+					js: require("../languages/js"),
+				},
+
+				/*
+				 * Because we try to delay loading rules until absolutely
+				 * necessary, a proxy allows us to hook into the lazy-loading
+				 * aspect of the rules map while still keeping all of the
+				 * relevant configuration inside of the config array.
+				 */
+				rules: new Proxy(
+					{},
+					{
+						get(target, property) {
+							return Rules.get(property);
+						},
 
-                languages: {
-                    js: require("../languages/js")
-                },
+						has(target, property) {
+							return Rules.has(property);
+						},
+					},
+				),
+			},
+		},
+		language: "@/js",
+		linterOptions: {
+			reportUnusedDisableDirectives: 1,
+		},
+	},
 
-                /*
-                 * Because we try to delay loading rules until absolutely
-                 * necessary, a proxy allows us to hook into the lazy-loading
-                 * aspect of the rules map while still keeping all of the
-                 * relevant configuration inside of the config array.
-                 */
-                rules: new Proxy({}, {
-                    get(target, property) {
-                        return Rules.get(property);
-                    },
+	// default ignores are listed here
+	{
+		ignores: ["**/node_modules/", ".git/"],
+	},
 
-                    has(target, property) {
-                        return Rules.has(property);
-                    }
-                })
-            }
-        },
-        language: "@/js",
-        linterOptions: {
-            reportUnusedDisableDirectives: 1
-        }
-    },
+	...sharedDefaultConfig,
+]);
 
-    // default ignores are listed here
-    {
-        ignores: [
-            "**/node_modules/",
-            ".git/"
-        ]
-    },
+exports.defaultRuleTesterConfig = Object.freeze([
+	{ files: ["**"] }, // Make sure the default config matches for all files
 
-    // intentionally empty config to ensure these files are globbed by default
-    {
-        files: ["**/*.js", "**/*.mjs"]
-    },
-    {
-        files: ["**/*.cjs"],
-        languageOptions: {
-            sourceType: "commonjs",
-            ecmaVersion: "latest"
-        }
-    }
+	...sharedDefaultConfig,
 ]);