eslint 9.26.0 → 9.28.0

package/lib/config/config.js

@@ -10,16 +10,31 @@
 //-----------------------------------------------------------------------------
 
 const { deepMergeArrays } = require("../shared/deep-merge-arrays");
-const { getRuleFromConfig } = require("./flat-config-helpers");
 const { flatConfigSchema, hasMethod } = require("./flat-config-schema");
-const { RuleValidator } = require("./rule-validator");
 const { ObjectSchema } = require("@eslint/config-array");
+const ajvImport = require("../shared/ajv");
+const ajv = ajvImport();
+const ruleReplacements = require("../../conf/replacements.json");
 
 //-----------------------------------------------------------------------------
-// Helpers
+// Typedefs
 //-----------------------------------------------------------------------------
 
-const ruleValidator = new RuleValidator();
+/**
+ * @import { RuleDefinition } from "@eslint/core";
+ * @import { Linter } from "eslint";
+ */
+
+//-----------------------------------------------------------------------------
+// Private Members
+//------------------------------------------------------------------------------
+
+// JSON schema that disallows passing any options
+const noOptionsSchema = Object.freeze({
+	type: "array",
+	minItems: 0,
+	maxItems: 0,
+});
 
 const severities = new Map([
 	[0, 0],
@@ -30,6 +45,174 @@ const severities = new Map([
 	["error", 2],
 ]);
 
+/**
+ * A collection of compiled validators for rules that have already
+ * been validated.
+ * @type {WeakMap}
+ */
+const validators = new WeakMap();
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+/**
+ * Throws a helpful error when a rule cannot be found.
+ * @param {Object} ruleId The rule identifier.
+ * @param {string} ruleId.pluginName The ID of the rule to find.
+ * @param {string} ruleId.ruleName The ID of the rule to find.
+ * @param {Object} config The config to search in.
+ * @throws {TypeError} For missing plugin or rule.
+ * @returns {void}
+ */
+function throwRuleNotFoundError({ pluginName, ruleName }, config) {
+	const ruleId = pluginName === "@" ? ruleName : `${pluginName}/${ruleName}`;
+
+	const errorMessageHeader = `Key "rules": Key "${ruleId}"`;
+
+	let errorMessage = `${errorMessageHeader}: Could not find plugin "${pluginName}" in configuration.`;
+
+	const missingPluginErrorMessage = errorMessage;
+
+	// if the plugin exists then we need to check if the rule exists
+	if (config.plugins && config.plugins[pluginName]) {
+		const replacementRuleName = ruleReplacements.rules[ruleName];
+
+		if (pluginName === "@" && replacementRuleName) {
+			errorMessage = `${errorMessageHeader}: Rule "${ruleName}" was removed and replaced by "${replacementRuleName}".`;
+		} else {
+			errorMessage = `${errorMessageHeader}: Could not find "${ruleName}" in plugin "${pluginName}".`;
+
+			// otherwise, let's see if we can find the rule name elsewhere
+			for (const [otherPluginName, otherPlugin] of Object.entries(
+				config.plugins,
+			)) {
+				if (otherPlugin.rules && otherPlugin.rules[ruleName]) {
+					errorMessage += ` Did you mean "${otherPluginName}/${ruleName}"?`;
+					break;
+				}
+			}
+		}
+
+		// falls through to throw error
+	}
+
+	const error = new TypeError(errorMessage);
+
+	if (errorMessage === missingPluginErrorMessage) {
+		error.messageTemplate = "config-plugin-missing";
+		error.messageData = { pluginName, ruleId };
+	}
+
+	throw error;
+}
+
+/**
+ * The error type when a rule has an invalid `meta.schema`.
+ */
+class InvalidRuleOptionsSchemaError extends Error {
+	/**
+	 * Creates a new instance.
+	 * @param {string} ruleId Id of the rule that has an invalid `meta.schema`.
+	 * @param {Error} processingError Error caught while processing the `meta.schema`.
+	 */
+	constructor(ruleId, processingError) {
+		super(
+			`Error while processing options validation schema of rule '${ruleId}': ${processingError.message}`,
+			{ cause: processingError },
+		);
+		this.code = "ESLINT_INVALID_RULE_OPTIONS_SCHEMA";
+	}
+}
+
+/**
+ * Parses a ruleId into its plugin and rule parts.
+ * @param {string} ruleId The rule ID to parse.
+ * @returns {{pluginName:string,ruleName:string}} The plugin and rule
+ *      parts of the ruleId;
+ */
+function parseRuleId(ruleId) {
+	let pluginName, ruleName;
+
+	// distinguish between core rules and plugin rules
+	if (ruleId.includes("/")) {
+		// mimic scoped npm packages
+		if (ruleId.startsWith("@")) {
+			pluginName = ruleId.slice(0, ruleId.lastIndexOf("/"));
+		} else {
+			pluginName = ruleId.slice(0, ruleId.indexOf("/"));
+		}
+
+		ruleName = ruleId.slice(pluginName.length + 1);
+	} else {
+		pluginName = "@";
+		ruleName = ruleId;
+	}
+
+	return {
+		pluginName,
+		ruleName,
+	};
+}
+
+/**
+ * Retrieves a rule instance from a given config based on the ruleId.
+ * @param {string} ruleId The rule ID to look for.
+ * @param {Linter.Config} config The config to search.
+ * @returns {RuleDefinition|undefined} The rule if found
+ *      or undefined if not.
+ */
+function getRuleFromConfig(ruleId, config) {
+	const { pluginName, ruleName } = parseRuleId(ruleId);
+
+	return config.plugins?.[pluginName]?.rules?.[ruleName];
+}
+
+/**
+ * Gets a complete options schema for a rule.
+ * @param {RuleDefinition} rule A rule object
+ * @throws {TypeError} If `meta.schema` is specified but is not an array, object or `false`.
+ * @returns {Object|null} JSON Schema for the rule's options. `null` if `meta.schema` is `false`.
+ */
+function getRuleOptionsSchema(rule) {
+	if (!rule.meta) {
+		return { ...noOptionsSchema }; // default if `meta.schema` is not specified
+	}
+
+	const schema = rule.meta.schema;
+
+	if (typeof schema === "undefined") {
+		return { ...noOptionsSchema }; // default if `meta.schema` is not specified
+	}
+
+	// `schema:false` is an allowed explicit opt-out of options validation for the rule
+	if (schema === false) {
+		return null;
+	}
+
+	if (typeof schema !== "object" || schema === null) {
+		throw new TypeError("Rule's `meta.schema` must be an array or object");
+	}
+
+	// ESLint-specific array form needs to be converted into a valid JSON Schema definition
+	if (Array.isArray(schema)) {
+		if (schema.length) {
+			return {
+				type: "array",
+				items: schema,
+				minItems: 0,
+				maxItems: schema.length,
+			};
+		}
+
+		// `schema:[]` is an explicit way to specify that the rule does not accept any options
+		return { ...noOptionsSchema };
+	}
+
+	// `schema:<object>` is assumed to be a valid JSON Schema definition
+	return schema;
+}
+
 /**
  * Splits a plugin identifier in the form a/b/c into two parts: a/b and c.
  * @param {string} identifier The identifier to parse.
@@ -82,6 +265,27 @@ function getObjectId(object) {
 	return name;
 }
 
+/**
+ * Asserts that a value is not a function.
+ * @param {any} value The value to check.
+ * @param {string} key The key of the value in the object.
+ * @param {string} objectKey The key of the object being checked.
+ * @returns {void}
+ * @throws {TypeError} If the value is a function.
+ */
+function assertNotFunction(value, key, objectKey) {
+	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 };
+
+		throw error;
+	}
+}
+
 /**
  * Converts a languageOptions object to a JSON representation.
  * @param {Record<string, any>} languageOptions The options to create a JSON
@@ -91,6 +295,14 @@ function getObjectId(object) {
  * @throws {TypeError} If a function is found in the languageOptions.
  */
 function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
+	if (typeof languageOptions.toJSON === "function") {
+		const result = languageOptions.toJSON();
+
+		assertNotFunction(result, "toJSON", objectKey);
+
+		return result;
+	}
+
 	const result = {};
 
 	for (const [key, value] of Object.entries(languageOptions)) {
@@ -98,7 +310,10 @@ function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
 			if (typeof value === "object") {
 				const name = getObjectId(value);
 
-				if (name && hasMethod(value)) {
+				if (typeof value.toJSON === "function") {
+					result[key] = value.toJSON();
+					assertNotFunction(result[key], key, objectKey);
+				} else if (name && hasMethod(value)) {
 					result[key] = name;
 				} else {
 					result[key] = languageOptionsToJSON(value, key);
@@ -106,16 +321,7 @@ function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
 				continue;
 			}
 
-			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 };
-
-				throw error;
-			}
+			assertNotFunction(value, key, objectKey);
 		}
 
 		result[key] = value;
@@ -124,6 +330,29 @@ function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") {
 	return result;
 }
 
+/**
+ * Gets or creates a validator for a rule.
+ * @param {Object} rule The rule to get a validator for.
+ * @param {string} ruleId The ID of the rule (for error reporting).
+ * @returns {Function|null} A validation function or null if no validation is needed.
+ * @throws {InvalidRuleOptionsSchemaError} If a rule's `meta.schema` is invalid.
+ */
+function getOrCreateValidator(rule, ruleId) {
+	if (!validators.has(rule)) {
+		try {
+			const schema = getRuleOptionsSchema(rule);
+
+			if (schema) {
+				validators.set(rule, ajv.compile(schema));
+			}
+		} catch (err) {
+			throw new InvalidRuleOptionsSchemaError(ruleId, err);
+		}
+	}
+
+	return validators.get(rule);
+}
+
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
@@ -252,7 +481,7 @@ class Config {
 		// Process the rules
 		if (this.rules) {
 			this.#normalizeRulesConfig();
-			ruleValidator.validate(this);
+			this.validateRulesConfig(this.rules);
 		}
 	}
 
@@ -291,6 +520,15 @@ class Config {
 		};
 	}
 
+	/**
+	 * Gets a rule configuration by its ID.
+	 * @param {string} ruleId The ID of the rule to get.
+	 * @returns {RuleDefinition|undefined} The rule definition from the plugin, or `undefined` if the rule is not found.
+	 */
+	getRuleDefinition(ruleId) {
+		return getRuleFromConfig(ruleId, this);
+	}
+
 	/**
 	 * Normalizes the rules configuration. Ensures that each rule config is
 	 * an array and that the severity is a number. Applies meta.defaultOptions.
@@ -323,6 +561,114 @@ class Config {
 			this.rules[ruleId] = ruleConfig;
 		}
 	}
+
+	/**
+	 * Validates all of the rule configurations in the given rules config
+	 * against the plugins in this instance. This is used primarily to
+	 * validate inline configuration rules while inting.
+	 * @param {Object} rulesConfig The rules config to validate.
+	 * @returns {void}
+	 * @throws {Error} If a rule's configuration does not match its schema.
+	 * @throws {TypeError} If the rulesConfig is not provided or is invalid.
+	 * @throws {InvalidRuleOptionsSchemaError} If a rule's `meta.schema` is invalid.
+	 * @throws {TypeError} If a rule is not found in the plugins.
+	 */
+	validateRulesConfig(rulesConfig) {
+		if (!rulesConfig) {
+			throw new TypeError("Config is required for validation.");
+		}
+
+		for (const [ruleId, ruleOptions] of Object.entries(rulesConfig)) {
+			// check for edge case
+			if (ruleId === "__proto__") {
+				continue;
+			}
+
+			/*
+			 * If a rule is disabled, we don't do any validation. This allows
+			 * users to safely set any value to 0 or "off" without worrying
+			 * that it will cause a validation error.
+			 *
+			 * Note: ruleOptions is always an array at this point because
+			 * this validation occurs after FlatConfigArray has merged and
+			 * normalized values.
+			 */
+			if (ruleOptions[0] === 0) {
+				continue;
+			}
+
+			const rule = getRuleFromConfig(ruleId, this);
+
+			if (!rule) {
+				throwRuleNotFoundError(parseRuleId(ruleId), this);
+			}
+
+			const validateRule = getOrCreateValidator(rule, ruleId);
+
+			if (validateRule) {
+				validateRule(ruleOptions.slice(1));
+
+				if (validateRule.errors) {
+					throw new Error(
+						`Key "rules": Key "${ruleId}":\n${validateRule.errors
+							.map(error => {
+								if (
+									error.keyword === "additionalProperties" &&
+									error.schema === false &&
+									typeof error.parentSchema?.properties ===
+										"object" &&
+									typeof error.params?.additionalProperty ===
+										"string"
+								) {
+									const expectedProperties = Object.keys(
+										error.parentSchema.properties,
+									).map(property => `"${property}"`);
+
+									return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n\t\tUnexpected property "${error.params.additionalProperty}". Expected properties: ${expectedProperties.join(", ")}.\n`;
+								}
+
+								return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`;
+							})
+							.join("")}`,
+					);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Gets a complete options schema for a rule.
+	 * @param {RuleDefinition} ruleDefinition A rule definition object.
+	 * @throws {TypeError} If `meta.schema` is specified but is not an array, object or `false`.
+	 * @returns {Object|null} JSON Schema for the rule's options. `null` if `meta.schema` is `false`.
+	 */
+	static getRuleOptionsSchema(ruleDefinition) {
+		return getRuleOptionsSchema(ruleDefinition);
+	}
+
+	/**
+	 * Normalizes the severity value of a rule's configuration to a number
+	 * @param {(number|string|[number, ...*]|[string, ...*])} ruleConfig A rule's configuration value, generally
+	 * received from the user. A valid config value is either 0, 1, 2, the string "off" (treated the same as 0),
+	 * the string "warn" (treated the same as 1), the string "error" (treated the same as 2), or an array
+	 * whose first element is one of the above values. Strings are matched case-insensitively.
+	 * @returns {(0|1|2)} The numeric severity value if the config value was valid, otherwise 0.
+	 */
+	static getRuleNumericSeverity(ruleConfig) {
+		const severityValue = Array.isArray(ruleConfig)
+			? ruleConfig[0]
+			: ruleConfig;
+
+		if (severities.has(severityValue)) {
+			return severities.get(severityValue);
+		}
+
+		if (typeof severityValue === "string") {
+			return severities.get(severityValue.toLowerCase()) ?? 0;
+		}
+
+		return 0;
+	}
 }
 
 module.exports = { Config };

package/lib/eslint/eslint-helpers.js

@@ -30,10 +30,12 @@ const MINIMATCH_OPTIONS = { dot: true };
 
 /**
  * @import { ESLintOptions } from "./eslint.js";
- * @import { LintMessage, LintResult } from "../shared/types.js";
  * @import { ConfigLoader, LegacyConfigLoader } from "../config/config-loader.js";
  */
 
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
+
 /**
  * @typedef {Object} GlobSearch
  * @property {Array<string>} patterns The normalized patterns to use for a search.

package/lib/eslint/eslint.js

@@ -14,7 +14,6 @@ const { existsSync } = require("node:fs");
 const path = require("node:path");
 const { version } = require("../../package.json");
 const { Linter } = require("../linter");
-const { getRuleFromConfig } = require("../config/flat-config-helpers");
 const { defaultConfig } = require("../config/default-config");
 const {
 	Legacy: {
@@ -41,6 +40,7 @@ const { pathToFileURL } = require("node:url");
 const LintResultCache = require("../cli-engine/lint-result-cache");
 const { Retrier } = require("@humanwhocodes/retry");
 const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
+const { WarningService } = require("../services/warning-service");
 
 /*
  * This is necessary to allow overwriting writeFile for testing purposes.
@@ -57,17 +57,21 @@ const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
  * @import { CLIEngineLintReport } from "./legacy-eslint.js";
  * @import { FlatConfigArray } from "../config/flat-config-array.js";
  * @import { RuleDefinition } from "@eslint/core";
- * @import { ConfigData, DeprecatedRuleInfo, LintMessage, LintResult, ResultsMeta } from "../shared/types.js";
  */
 
 /** @typedef {ReturnType<ConfigArray.extractConfig>} ExtractedConfig */
+/** @typedef {import("../types").Linter.Config} Config */
+/** @typedef {import("../types").ESLint.DeprecatedRuleUse} DeprecatedRuleInfo */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
 /** @typedef {import("../types").ESLint.Plugin} Plugin */
+/** @typedef {import("../types").ESLint.ResultsMeta} ResultsMeta */
 
 /**
  * The options with which to configure the ESLint instance.
  * @typedef {Object} ESLintOptions
  * @property {boolean} [allowInlineConfig] Enable or disable inline configuration comments.
- * @property {ConfigData|Array<ConfigData>} [baseConfig] Base config, extended by all configs used with this instance
+ * @property {Config|Array<Config>} [baseConfig] Base config, extended by all configs used with this instance
  * @property {boolean} [cache] Enable result caching.
  * @property {string} [cacheLocation] The cache file to use instead of .eslintcache.
  * @property {"metadata" | "content"} [cacheStrategy] The strategy used to detect changed files.
@@ -79,7 +83,7 @@ const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
  * @property {boolean} [globInputPaths] Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
  * @property {boolean} [ignore] False disables all ignore patterns except for the default ones.
  * @property {string[]} [ignorePatterns] Ignore file patterns to use in addition to config ignores. These patterns are relative to `cwd`.
- * @property {ConfigData|Array<ConfigData>} [overrideConfig] Override config, overrides all configs used with this instance
+ * @property {Config|Array<Config>} [overrideConfig] Override config, overrides all configs used with this instance
  * @property {boolean|string} [overrideConfigFile] Searches for default config file when falsy;
  *      doesn't do any config file lookup when `true`; considered to be a config filename
  *      when a string.
@@ -159,7 +163,7 @@ function getOrFindUsedDeprecatedRules(eslint, maybeFilePath) {
 				if (getRuleSeverity(ruleConf) === 0) {
 					continue;
 				}
-				const rule = getRuleFromConfig(ruleId, config);
+				const rule = config.getRuleDefinition(ruleId);
 				const meta = rule && rule.meta;
 
 				if (meta && meta.deprecated) {
@@ -353,7 +357,7 @@ function shouldMessageBeFixed(message, config, fixTypes) {
 		return fixTypes.has("directive");
 	}
 
-	const rule = message.ruleId && getRuleFromConfig(message.ruleId, config);
+	const rule = message.ruleId && config.getRuleDefinition(message.ruleId);
 
 	return Boolean(rule && rule.meta && fixTypes.has(rule.meta.type));
 }
@@ -387,6 +391,20 @@ function getFixerForFixTypes(fix, fixTypesSet, config) {
 		originalFix(message);
 }
 
+/**
+ * Retrieves flags from the environment variable ESLINT_FLAGS.
+ * @param {string[]} flags The flags defined via the API.
+ * @returns {string[]} The merged flags to use.
+ */
+function mergeEnvironmentFlags(flags) {
+	if (!process.env.ESLINT_FLAGS) {
+		return flags;
+	}
+
+	const envFlags = process.env.ESLINT_FLAGS.trim().split(/\s*,\s*/gu);
+	return Array.from(new Set([...envFlags, ...flags]));
+}
+
 //-----------------------------------------------------------------------------
 // Main API
 //-----------------------------------------------------------------------------
@@ -414,10 +432,12 @@ class ESLint {
 	constructor(options = {}) {
 		const defaultConfigs = [];
 		const processedOptions = processOptions(options);
+		const warningService = new WarningService();
 		const linter = new Linter({
 			cwd: processedOptions.cwd,
 			configType: "flat",
-			flags: processedOptions.flags,
+			flags: mergeEnvironmentFlags(processedOptions.flags),
+			warningService,
 		});
 
 		const cacheFilePath = getCacheFile(
@@ -440,6 +460,7 @@ class ESLint {
 			hasUnstableNativeNodeJsTSConfigFlag: linter.hasFlag(
 				"unstable_native_nodejs_ts_config",
 			),
+			warningService,
 		};
 
 		this.#configLoader = linter.hasFlag("unstable_config_lookup_from_file")
@@ -479,10 +500,7 @@ class ESLint {
 
 		// Check for the .eslintignore file, and warn if it's present.
 		if (existsSync(path.resolve(processedOptions.cwd, ".eslintignore"))) {
-			process.emitWarning(
-				'The ".eslintignore" file is no longer supported. Switch to using the "ignores" property in "eslint.config.js": https://eslint.org/docs/latest/use/configure/migration-guide#ignoring-files',
-				"ESLintIgnoreWarning",
-			);
+			warningService.emitESLintIgnoreWarning();
 		}
 	}
 
@@ -611,7 +629,7 @@ class ESLint {
 				if (!config) {
 					throw createExtraneousResultsError();
 				}
-				const rule = getRuleFromConfig(ruleId, config);
+				const rule = config.getRuleDefinition(ruleId);
 
 				// ignore unknown rules
 				if (rule) {
@@ -1068,7 +1086,7 @@ class ESLint {
 	 * 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 to retrieve a config object for.
-	 * @returns {Promise<ConfigData|undefined>} A configuration object for the file
+	 * @returns {Promise<Config|undefined>} A configuration object for the file
 	 *      or `undefined` if there is no configuration data for the object.
 	 */
 	async calculateConfigForFile(filePath) {

package/lib/eslint/legacy-eslint.js

@@ -30,14 +30,14 @@ const { version } = require("../../package.json");
 //------------------------------------------------------------------------------
 
 /** @typedef {import("../cli-engine/cli-engine").LintReport} CLIEngineLintReport */
-/** @typedef {import("../shared/types").DeprecatedRuleInfo} DeprecatedRuleInfo */
-/** @typedef {import("../shared/types").ConfigData} ConfigData */
-/** @typedef {import("../shared/types").LintMessage} LintMessage */
-/** @typedef {import("../shared/types").SuppressedLintMessage} SuppressedLintMessage */
-/** @typedef {import("../shared/types").LintResult} LintResult */
-/** @typedef {import("../shared/types").ResultsMeta} ResultsMeta */
+/** @typedef {import("../types").ESLint.ConfigData} ConfigData */
+/** @typedef {import("../types").ESLint.DeprecatedRuleUse} DeprecatedRuleInfo */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").ESLint.LintResult} LintResult */
 /** @typedef {import("../types").ESLint.Plugin} Plugin */
+/** @typedef {import("../types").ESLint.ResultsMeta} ResultsMeta */
 /** @typedef {import("../types").Rule.RuleModule} Rule */
+/** @typedef {import("../types").Linter.SuppressedLintMessage} SuppressedLintMessage */
 
 /**
  * The main formatter object.