eslint 9.25.1 → 9.27.0

package/lib/types/index.d.ts

@@ -35,7 +35,6 @@ import type {
 	LanguageOptions as GenericLanguageOptions,
 	RuleDefinition,
 	RuleContext as CoreRuleContext,
-	RuleContextTypeOptions,
 	DeprecatedInfo,
 } from "@eslint/core";
 import { JSONSchema4 } from "json-schema";
@@ -1561,9 +1560,16 @@ export namespace Linter {
 	/**
 	 * Parser options.
 	 *
-	 * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options)
+	 * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options)
 	 */
 	interface ParserOptions {
+		/**
+		 * Allow the use of reserved words as identifiers (if `ecmaVersion` is 3).
+		 *
+		 * @default false
+		 */
+		allowReserved?: boolean | undefined;
+
 		/**
 		 * Accepts any valid ECMAScript version number or `'latest'`:
 		 *
@@ -1620,26 +1626,54 @@ export namespace Linter {
 	}
 
 	interface LintSuggestion {
+		/** A short description. */
 		desc: string;
+
+		/** Fix result info. */
 		fix: Rule.Fix;
+
+		/** Id referencing a message for the description. */
 		messageId?: string | undefined;
 	}
 
 	interface LintMessage {
+		/** The 1-based column number. */
 		column: number;
+
+		/** The 1-based line number. */
 		line: number;
+
+		/** The 1-based column number of the end location. */
 		endColumn?: number | undefined;
+
+		/** The 1-based line number of the end location. */
 		endLine?: number | undefined;
+
+		/** The ID of the rule which makes this message. */
 		ruleId: string | null;
+
+		/** The reported message. */
 		message: string;
+
+		/** The ID of the message in the rule's meta. */
 		messageId?: string | undefined;
+
 		/**
+		 * Type of node.
 		 * @deprecated `nodeType` is deprecated and will be removed in the next major version.
 		 */
 		nodeType?: string | undefined;
+
+		/** If `true` then this is a fatal error. */
 		fatal?: true | undefined;
+
+		/** The severity of this message. */
 		severity: Exclude<Severity, 0>;
+
+		/** Information for autofix. */
 		fix?: Rule.Fix | undefined;
+
+		/** Information for suggestions. */
 		suggestions?: LintSuggestion[] | undefined;
 	}
 
@@ -1649,6 +1683,7 @@ export namespace Linter {
 	}
 
 	interface SuppressedLintMessage extends LintMessage {
+		/** The suppression info. */
 		suppressions: LintSuppression[];
 	}
 
@@ -1662,8 +1697,8 @@ export namespace Linter {
 		messages: LintMessage[];
 	}
 
-	// Temporarily loosen type for just flat config files (see #68232)
-	type NonESTreeParser = Omit<ESTreeParser, "parseForESLint"> &
+	// Temporarily loosen type for just flat config files (see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68232)
+	type NonESTreeParser = ESLint.ObjectMetaProperties &
 		(
 			| {
 					parse(text: string, options?: any): unknown;
@@ -1688,9 +1723,16 @@ export namespace Linter {
 	type Parser = NonESTreeParser | ESTreeParser;
 
 	interface ESLintParseResult {
+		/** The AST object. */
 		ast: AST.Program;
-		parserServices?: SourceCode.ParserServices | undefined;
+
+		/** The services that the parser provides. */
+		services?: SourceCode.ParserServices | undefined;
+
+		/** The scope manager of the AST. */
 		scopeManager?: Scope.ScopeManager | undefined;
+
+		/** The visitor keys of the AST. */
 		visitorKeys?: SourceCode.VisitorKeys | undefined;
 	}
 
@@ -1703,8 +1745,13 @@ export namespace Linter {
 	interface Processor<
 		T extends string | ProcessorFile = string | ProcessorFile,
 	> extends ESLint.ObjectMetaProperties {
+		/** If `true` then it means the processor supports autofix. */
 		supportsAutofix?: boolean | undefined;
+
+		/** The function to extract code blocks. */
 		preprocess?(text: string, filename: string): T[];
+
+		/** The function to merge messages. */
 		postprocess?(
 			messages: LintMessage[][],
 			filename: string,
@@ -1845,6 +1892,9 @@ export namespace Linter {
 		reportUnusedInlineConfigs?: Severity | StringSeverity;
 	}
 
+	/**
+	 * Performance statistics.
+	 */
 	interface Stats {
 		/**
 		 * The number of times ESLint has applied at least one fix after linting.
@@ -1858,9 +1908,24 @@ export namespace Linter {
 	}
 
 	interface TimePass {
+		/**
+		 * The parse object containing all parse time information.
+		 */
 		parse: { total: number };
+
+		/**
+		 * The rules object containing all lint time information for each rule.
+		 */
 		rules?: Record<string, { total: number }>;
+
+		/**
+		 * The fix object containing all fix time information.
+		 */
 		fix: { total: number };
+
+		/**
+		 * The total time that is spent on (parsing, fixing, linting) a file.
+		 */
 		total: number;
 	}
 }
@@ -1916,7 +1981,10 @@ export namespace ESLint {
 		Omit<Linter.LegacyConfig<Rules>, "$schema">;
 
 	interface Environment {
+		/** The definition of global variables. */
 		globals?: Linter.Globals | undefined;
+
+		/** The parser options that will be enabled under this environment. */
 		parserOptions?: Linter.ParserOptions | undefined;
 	}
 
@@ -1934,6 +2002,9 @@ export namespace ESLint {
 	}
 
 	interface Plugin extends ObjectMetaProperties {
+		meta?: ObjectMetaProperties["meta"] & {
+			namespace?: string | undefined;
+		};
 		configs?:
 			| Record<
 					string,
@@ -2020,21 +2091,48 @@ export namespace ESLint {
 		flags?: string[] | undefined;
 	}
 
+	/** A linting result. */
 	interface LintResult {
+		/** The path to the file that was linted. */
 		filePath: string;
+
+		/** All of the messages for the result. */
 		messages: Linter.LintMessage[];
+
+		/** All of the suppressed messages for the result. */
 		suppressedMessages: Linter.SuppressedLintMessage[];
+
+		/** Number of errors for the result. */
 		errorCount: number;
+
+		/** Number of fatal errors for the result. */
 		fatalErrorCount: number;
+
+		/** Number of warnings for the result. */
 		warningCount: number;
+
+		/** Number of fixable errors for the result. */
 		fixableErrorCount: number;
+
+		/** Number of fixable warnings for the result. */
 		fixableWarningCount: number;
+
+		/** The source code of the file that was linted, with as many fixes applied as possible. */
 		output?: string | undefined;
+
+		/** The source code of the file that was linted. */
 		source?: string | undefined;
+
+		/** The performance statistics collected with the `stats` flag. */
 		stats?: Linter.Stats | undefined;
+
+		/** The list of used deprecated rules. */
 		usedDeprecatedRules: DeprecatedRuleUse[];
 	}
 
+	/**
+	 * Information provided when the maximum warning threshold is exceeded.
+	 */
 	interface MaxWarningsExceeded {
 		/**
 		 * Number of warnings to trigger nonzero exit code.
@@ -2055,12 +2153,34 @@ export namespace ESLint {
 		};
 	}
 
+	/**
+	 * Information about deprecated rules.
+	 */
 	interface DeprecatedRuleUse {
+		/**
+		 * The rule ID.
+		 */
 		ruleId: string;
+
+		/**
+		 * The rule IDs that replace this deprecated rule.
+		 */
 		replacedBy: string[];
+
+		/**
+		 * The raw deprecated info provided by the rule.
+		 * Unset if the rule's `meta.deprecated` property is a boolean.
+		 */
+		info?: DeprecatedInfo;
 	}
 
+	/**
+	 * Metadata about results for formatters.
+	 */
 	interface ResultsMeta {
+		/**
+		 * Present if the maxWarnings threshold was exceeded.
+		 */
 		maxWarningsExceeded?: MaxWarningsExceeded | undefined;
 	}
 
@@ -2121,7 +2241,7 @@ export class RuleTester {
 
 	run(
 		name: string,
-		rule: Rule.RuleModule,
+		rule: RuleDefinition,
 		tests: {
 			valid: Array<string | RuleTester.ValidTestCase>;
 			invalid: RuleTester.InvalidTestCase[];

package/lib/types/rules.d.ts

@@ -1800,6 +1800,10 @@ export interface ESLintRules extends Linter.RulesRecord {
 					 * @default 3
 					 */
 					max: number;
+					/**
+					 * @default false
+					 */
+					countVoidThis: boolean;
 			  }>
 			| number,
 		]
@@ -3578,7 +3582,16 @@ export interface ESLintRules extends Linter.RulesRecord {
 	 * @since 0.1.4
 	 * @see https://eslint.org/docs/latest/rules/no-shadow-restricted-names
 	 */
-	"no-shadow-restricted-names": Linter.RuleEntry<[]>;
+	"no-shadow-restricted-names": Linter.RuleEntry<
+		[
+			Partial<{
+				/**
+				 * @default false
+				 */
+				reportGlobalThis: boolean;
+			}>,
+		]
+	>;
 
 	/**
 	 * Rule to disallow spacing between function identifiers and their applications (deprecated).
@@ -3701,6 +3714,14 @@ export interface ESLintRules extends Linter.RulesRecord {
 		]
 	>;
 
+	/**
+	 * Rule to disallow `let` or `var` variables that are read but never assigned.
+	 *
+	 * @since 9.27.0
+	 * @see https://eslint.org/docs/latest/rules/no-unassigned-vars
+	 */
+	"no-unassigned-vars": Linter.RuleEntry<[]>;
+
 	/**
 	 * Rule to disallow the use of undeclared variables unless mentioned in \/*global *\/ comments.
 	 *
@@ -3935,6 +3956,10 @@ export interface ESLintRules extends Linter.RulesRecord {
 				 * @default false
 				 */
 				enforceForJSX: boolean;
+				/**
+				 * @default false
+				 */
+				ignoreDirectives: boolean;
 			}>,
 		]
 	>;
@@ -4117,7 +4142,13 @@ export interface ESLintRules extends Linter.RulesRecord {
 	 * @since 2.5.0
 	 * @see https://eslint.org/docs/latest/rules/no-useless-escape
 	 */
-	"no-useless-escape": Linter.RuleEntry<[]>;
+	"no-useless-escape": Linter.RuleEntry<
+		[
+			Partial<{
+				allowRegexCharacters: string[];
+			}>,
+		]
+	>;
 
 	/**
 	 * Rule to disallow renaming import, export, and destructured assignments to the same name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.25.1",
+  "version": "9.27.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "type": "commonjs",
@@ -108,10 +108,10 @@
     "@eslint-community/regexpp": "^4.12.1",
     "@eslint/config-array": "^0.20.0",
     "@eslint/config-helpers": "^0.2.1",
-    "@eslint/core": "^0.13.0",
+    "@eslint/core": "^0.14.0",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "9.25.1",
-    "@eslint/plugin-kit": "^0.2.8",
+    "@eslint/js": "9.27.0",
+    "@eslint/plugin-kit": "^0.3.1",
     "@humanfs/node": "^0.16.6",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@humanwhocodes/retry": "^0.4.2",
@@ -141,12 +141,13 @@
     "optionator": "^0.9.3"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.17.0",
+    "@arethetypeswrong/cli": "^0.18.0",
     "@babel/core": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
     "@cypress/webpack-preprocessor": "^6.0.2",
-    "@eslint/json": "^0.11.0",
+    "@eslint/json": "^0.12.0",
     "@trunkio/launcher": "^1.3.4",
+    "@types/esquery": "^1.5.4",
     "@types/node": "^22.13.14",
     "@typescript-eslint/parser": "^8.4.0",
     "babel-loader": "^8.0.5",

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

@@ -1,128 +0,0 @@
-/**
- * @fileoverview Shared functions to work with configs.
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/**
- * @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,
-});
-
-//-----------------------------------------------------------------------------
-// Functions
-//-----------------------------------------------------------------------------
-
-/**
- * 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;
-}
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-module.exports = {
-	parseRuleId,
-	getRuleFromConfig,
-	getRuleOptionsSchema,
-};

package/lib/config/rule-validator.js

@@ -1,199 +0,0 @@
-/**
- * @fileoverview Rule Validator
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Requirements
-//-----------------------------------------------------------------------------
-
-const ajvImport = require("../shared/ajv");
-const ajv = ajvImport();
-const {
-	parseRuleId,
-	getRuleFromConfig,
-	getRuleOptionsSchema,
-} = require("./flat-config-helpers");
-const ruleReplacements = require("../../conf/replacements.json");
-
-//-----------------------------------------------------------------------------
-// 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";
-	}
-}
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-/**
- * Implements validation functionality for the rules portion of a config.
- */
-class RuleValidator {
-	/**
-	 * Creates a new instance.
-	 */
-	constructor() {
-		/**
-		 * A collection of compiled validators for rules that have already
-		 * been validated.
-		 * @type {WeakMap}
-		 */
-		this.validators = new WeakMap();
-	}
-
-	/**
-	 * Validates all of the rule configurations in a config against each
-	 * rule's schema.
-	 * @param {Object} config The full config to validate. This object must
-	 *      contain both the rules section and the plugins section.
-	 * @returns {void}
-	 * @throws {Error} If a rule's configuration does not match its schema.
-	 */
-	validate(config) {
-		if (!config.rules) {
-			return;
-		}
-
-		for (const [ruleId, ruleOptions] of Object.entries(config.rules)) {
-			// 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, config);
-
-			if (!rule) {
-				throwRuleNotFoundError(parseRuleId(ruleId), config);
-			}
-
-			// Precompile and cache validator the first time
-			if (!this.validators.has(rule)) {
-				try {
-					const schema = getRuleOptionsSchema(rule);
-
-					if (schema) {
-						this.validators.set(rule, ajv.compile(schema));
-					}
-				} catch (err) {
-					throw new InvalidRuleOptionsSchemaError(ruleId, err);
-				}
-			}
-
-			const validateRule = this.validators.get(rule);
-
-			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("")}`,
-					);
-				}
-			}
-		}
-	}
-}
-
-exports.RuleValidator = RuleValidator;