eslint 9.26.0 → 9.27.0

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: {
@@ -57,17 +56,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 +82,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 +162,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 +356,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 +390,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
 //-----------------------------------------------------------------------------
@@ -417,7 +434,7 @@ class ESLint {
 		const linter = new Linter({
 			cwd: processedOptions.cwd,
 			configType: "flat",
-			flags: processedOptions.flags,
+			flags: mergeEnvironmentFlags(processedOptions.flags),
 		});
 
 		const cacheFilePath = getCacheFile(
@@ -611,7 +628,7 @@ class ESLint {
 				if (!config) {
 					throw createExtraneousResultsError();
 				}
-				const rule = getRuleFromConfig(ruleId, config);
+				const rule = config.getRuleDefinition(ruleId);
 
 				// ignore unknown rules
 				if (rule) {
@@ -1068,7 +1085,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.

package/lib/languages/js/source-code/source-code.js

@@ -53,7 +53,7 @@ const CODE_PATH_EVENTS = [
 /**
  * Validates that the given AST has the required information.
  * @param {ASTNode} ast The Program node of the AST to check.
- * @throws {Error} If the AST doesn't contain the correct information.
+ * @throws {TypeError} If the AST doesn't contain the correct information.
  * @returns {void}
  * @private
  */
@@ -147,8 +147,8 @@ function sortedMerge(tokens, comments) {
  * Normalizes a value for a global in a config
  * @param {(boolean|string|null)} configuredValue The value given for a global in configuration or in
  * a global directive comment
- * @returns {("readable"|"writeable"|"off")} The value normalized as a string
- * @throws Error if global value is invalid
+ * @returns {("readonly"|"writable"|"off")} The value normalized as a string
+ * @throws {Error} if global value is invalid
  */
 function normalizeConfigGlobal(configuredValue) {
 	switch (configuredValue) {
@@ -471,6 +471,10 @@ class SourceCode extends TokenStore {
 		 * @type {string[]}
 		 */
 		this.lines = [];
+
+		/**
+		 * @type {number[]}
+		 */
 		this.lineStartIndices = [0];
 
 		const lineEndingPattern = astUtils.createGlobalLinebreakMatcher();
@@ -528,7 +532,7 @@ class SourceCode extends TokenStore {
 
 	/**
 	 * Gets the entire source text split into an array of lines.
-	 * @returns {Array} The source text as an array of lines.
+	 * @returns {string[]} The source text as an array of lines.
 	 * @public
 	 */
 	getLines() {
@@ -687,8 +691,8 @@ class SourceCode extends TokenStore {
 	/**
 	 * Converts a source text index into a (line, column) pair.
 	 * @param {number} index The index of a character in a file
-	 * @throws {TypeError} If non-numeric index or index out of range.
-	 * @returns {Object} A {line, column} location object with a 0-indexed column
+	 * @throws {TypeError|RangeError} If non-numeric index or index out of range.
+	 * @returns {{line: number, column: number}} A {line, column} location object with a 0-indexed column
 	 * @public
 	 */
 	getLocFromIndex(index) {

package/lib/linter/apply-disable-directives.js

@@ -9,7 +9,7 @@
 // Typedefs
 //------------------------------------------------------------------------------
 
-/** @typedef {import("../shared/types").LintMessage} LintMessage */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
 /** @typedef {import("@eslint/core").Language} Language */
 /** @typedef {import("@eslint/core").Position} Position */
 /** @typedef {import("@eslint/core").RulesConfig} RulesConfig */

package/lib/linter/file-context.js

@@ -128,6 +128,17 @@ class FileContext {
 	getSourceCode() {
 		return this.sourceCode;
 	}
+
+	/**
+	 * Creates a new object with the current object as the prototype and
+	 * the specified properties as its own properties.
+	 * @param {Object} extension The properties to add to the new object.
+	 * @returns {FileContext} A new object with the current object as the prototype
+	 * and the specified properties as its own properties.
+	 */
+	extend(extension) {
+		return Object.freeze(Object.assign(Object.create(this), extension));
+	}
 }
 
 exports.FileContext = FileContext;

package/lib/linter/linter.js

@@ -34,10 +34,8 @@ const path = require("node:path"),
 	SourceCodeFixer = require("./source-code-fixer"),
 	timing = require("./timing"),
 	ruleReplacements = require("../../conf/replacements.json");
-const { getRuleFromConfig } = require("../config/flat-config-helpers");
 const { FlatConfigArray } = require("../config/flat-config-array");
 const { startTime, endTime } = require("../shared/stats");
-const { RuleValidator } = require("../config/rule-validator");
 const { assertIsRuleSeverity } = require("../config/flat-config-schema");
 const {
 	normalizeSeverityToString,
@@ -66,6 +64,7 @@ const { ParserService } = require("../services/parser-service");
 const { FileContext } = require("./file-context");
 const { ProcessorService } = require("../services/processor-service");
 const { containsDifferentProperty } = require("../shared/option-utils");
+const { Config } = require("../config/config");
 const STEP_KIND_VISIT = 1;
 const STEP_KIND_CALL = 2;
 
@@ -75,17 +74,19 @@ const STEP_KIND_CALL = 2;
 
 /** @import { Language, LanguageOptions, RuleConfig, RuleDefinition, RuleSeverity } from "@eslint/core" */
 
-/** @typedef {import("../shared/types").ConfigData} ConfigData */
-/** @typedef {import("../shared/types").Environment} Environment */
-/** @typedef {import("../shared/types").GlobalConf} GlobalConf */
-/** @typedef {import("../shared/types").LintMessage} LintMessage */
-/** @typedef {import("../shared/types").SuppressedLintMessage} SuppressedLintMessage */
-/** @typedef {import("../shared/types").ParserOptions} ParserOptions */
-/** @typedef {import("../shared/types").Processor} Processor */
-/** @typedef {import("../shared/types").Times} Times */
+/** @typedef {import("../types").Linter.Config} Config */
+/** @typedef {import("../types").ESLint.ConfigData} ConfigData */
+/** @typedef {import("../types").ESLint.Environment} Environment */
+/** @typedef {import("../types").Linter.GlobalConf} GlobalConf */
 /** @typedef {import("../types").Linter.LanguageOptions} JSLanguageOptions */
-/** @typedef {import("../types").Linter.StringSeverity} StringSeverity */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").Linter.Parser} Parser */
+/** @typedef {import("../types").Linter.ParserOptions} ParserOptions */
+/** @typedef {import("../types").Linter.Processor} Processor */
 /** @typedef {import("../types").Rule.RuleModule} Rule */
+/** @typedef {import("../types").Linter.StringSeverity} StringSeverity */
+/** @typedef {import("../types").Linter.SuppressedLintMessage} SuppressedLintMessage */
+/** @typedef {import("../types").Linter.TimePass} TimePass */
 
 /* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/4#issuecomment-778805577 */
 /**
@@ -110,7 +111,7 @@ const STEP_KIND_CALL = 2;
  * @property {SourceCode|null} lastSourceCode The `SourceCode` instance that the last `verify()` call used.
  * @property {SuppressedLintMessage[]} lastSuppressedMessages The `SuppressedLintMessage[]` instance that the last `verify()` call produced.
  * @property {Map<string, Parser>} parserMap The loaded parsers.
- * @property {Times} times The times spent on applying a rule to a file (see `stats` option).
+ * @property {{ passes: TimePass[]; }} times The times spent on applying a rule to a file (see `stats` option).
  * @property {Rules} ruleMap The loaded rules.
  */
 
@@ -350,7 +351,7 @@ function asArray(value) {
 
 /**
  * Pushes a problem to inlineConfigProblems if ruleOptions are redundant.
- * @param {ConfigData} config Provided config.
+ * @param {Config} config Provided config.
  * @param {Object} loc A line/column location
  * @param {Array} problems Problems that may be added to.
  * @param {string} ruleId The rule ID.
@@ -901,7 +902,7 @@ function normalizeFilename(filename) {
  * Normalizes the possible options for `linter.verify` and `linter.verifyAndFix` to a
  * consistent shape.
  * @param {VerifyOptions} providedOptions Options
- * @param {ConfigData} config Config.
+ * @param {Config|ConfigData} config Config.
  * @returns {Required<VerifyOptions> & InternalOptions} Normalized options
  */
 function normalizeVerifyOptions(providedOptions, config) {
@@ -1184,7 +1185,7 @@ function runRules(
 	 * All rule contexts will inherit from this object. This avoids the performance penalty of copying all the
 	 * properties once for each rule.
 	 */
-	const sharedTraversalContext = new FileContext({
+	const fileContext = new FileContext({
 		cwd,
 		filename,
 		physicalFilename: physicalFilename || filename,
@@ -1200,7 +1201,7 @@ function runRules(
 	const lintingProblems = [];
 
 	Object.keys(configuredRules).forEach(ruleId => {
-		const severity = ConfigOps.getRuleSeverity(configuredRules[ruleId]);
+		const severity = Config.getRuleNumericSeverity(configuredRules[ruleId]);
 
 		// not load disabled rules
 		if (severity === 0) {
@@ -1220,63 +1221,61 @@ function runRules(
 
 		const messageIds = rule.meta && rule.meta.messages;
 		let reportTranslator = null;
-		const ruleContext = Object.freeze(
-			Object.assign(Object.create(sharedTraversalContext), {
-				id: ruleId,
-				options: getRuleOptions(
-					configuredRules[ruleId],
-					applyDefaultOptions ? rule.meta?.defaultOptions : void 0,
-				),
-				report(...args) {
-					/*
-					 * Create a report translator lazily.
-					 * In a vast majority of cases, any given rule reports zero errors on a given
-					 * piece of code. Creating a translator lazily avoids the performance cost of
-					 * creating a new translator function for each rule that usually doesn't get
-					 * called.
-					 *
-					 * Using lazy report translators improves end-to-end performance by about 3%
-					 * with Node 8.4.0.
-					 */
-					if (reportTranslator === null) {
-						reportTranslator = createReportTranslator({
-							ruleId,
-							severity,
-							sourceCode,
-							messageIds,
-							disableFixes,
-							language,
-						});
-					}
-					const problem = reportTranslator(...args);
+		const ruleContext = fileContext.extend({
+			id: ruleId,
+			options: getRuleOptions(
+				configuredRules[ruleId],
+				applyDefaultOptions ? rule.meta?.defaultOptions : void 0,
+			),
+			report(...args) {
+				/*
+				 * Create a report translator lazily.
+				 * In a vast majority of cases, any given rule reports zero errors on a given
+				 * piece of code. Creating a translator lazily avoids the performance cost of
+				 * creating a new translator function for each rule that usually doesn't get
+				 * called.
+				 *
+				 * Using lazy report translators improves end-to-end performance by about 3%
+				 * with Node 8.4.0.
+				 */
+				if (reportTranslator === null) {
+					reportTranslator = createReportTranslator({
+						ruleId,
+						severity,
+						sourceCode,
+						messageIds,
+						disableFixes,
+						language,
+					});
+				}
+				const problem = reportTranslator(...args);
 
-					if (problem.fix && !(rule.meta && rule.meta.fixable)) {
-						throw new Error(
-							'Fixable rules must set the `meta.fixable` property to "code" or "whitespace".',
-						);
-					}
+				if (problem.fix && !(rule.meta && rule.meta.fixable)) {
+					throw new Error(
+						'Fixable rules must set the `meta.fixable` property to "code" or "whitespace".',
+					);
+				}
+				if (
+					problem.suggestions &&
+					!(rule.meta && rule.meta.hasSuggestions === true)
+				) {
 					if (
-						problem.suggestions &&
-						!(rule.meta && rule.meta.hasSuggestions === true)
+						rule.meta &&
+						rule.meta.docs &&
+						typeof rule.meta.docs.suggestion !== "undefined"
 					) {
-						if (
-							rule.meta &&
-							rule.meta.docs &&
-							typeof rule.meta.docs.suggestion !== "undefined"
-						) {
-							// Encourage migration from the former property name.
-							throw new Error(
-								"Rules with suggestions must set the `meta.hasSuggestions` property to `true`. `meta.docs.suggestion` is ignored by ESLint.",
-							);
-						}
+						// Encourage migration from the former property name.
 						throw new Error(
-							"Rules with suggestions must set the `meta.hasSuggestions` property to `true`.",
+							"Rules with suggestions must set the `meta.hasSuggestions` property to `true`. `meta.docs.suggestion` is ignored by ESLint.",
 						);
 					}
-					lintingProblems.push(problem);
-				},
-			}),
-		);
+					throw new Error(
+						"Rules with suggestions must set the `meta.hasSuggestions` property to `true`.",
+					);
+				}
+				lintingProblems.push(problem);
+			},
+		});
 
 		const ruleListenersReturn =
 			timing.enabled || stats
@@ -1885,7 +1884,7 @@ class Linter {
 	/**
 	 * Verify with a processor.
 	 * @param {string|SourceCode} textOrSourceCode The source code.
-	 * @param {FlatConfig} config The config array.
+	 * @param {Config} config The config array.
 	 * @param {VerifyOptions&ProcessorOptions} options The options.
 	 * @param {FlatConfigArray} [configForRecursive] The `ConfigArray` object to apply multiple processors recursively.
 	 * @returns {(LintMessage|SuppressedLintMessage)[]} The found problems.
@@ -1986,7 +1985,7 @@ class Linter {
 	/**
 	 * Verify using flat config and without any processors.
 	 * @param {VFile} file The file to lint.
-	 * @param {FlatConfig} providedConfig An ESLintConfig instance to configure everything.
+	 * @param {Config} providedConfig An ESLintConfig instance to configure everything.
 	 * @param {VerifyOptions} [providedOptions] The optional filename of the file being checked.
 	 * @throws {Error} If during rule execution.
 	 * @returns {(LintMessage|SuppressedLintMessage)[]} The results as an array of messages or an empty array if no messages.
@@ -2100,15 +2099,12 @@ class Linter {
 							}),
 					);
 
-					// next we need to verify information about the specified rules
-					const ruleValidator = new RuleValidator();
-
 					for (const {
 						config: inlineConfig,
 						loc,
 					} of inlineConfigResult.configs) {
 						Object.keys(inlineConfig.rules).forEach(ruleId => {
-							const rule = getRuleFromConfig(ruleId, config);
+							const rule = config.getRuleDefinition(ruleId);
 							const ruleValue = inlineConfig.rules[ruleId];
 
 							if (!rule) {
@@ -2218,11 +2214,8 @@ class Linter {
 								}
 
 								if (shouldValidateOptions) {
-									ruleValidator.validate({
-										plugins: config.plugins,
-										rules: {
-											[ruleId]: ruleOptions,
-										},
+									config.validateRulesConfig({
+										[ruleId]: ruleOptions,
 									});
 								}
 
@@ -2270,7 +2263,7 @@ class Linter {
 			options.allowInlineConfig && !options.warnInlineConfig
 				? getDirectiveCommentsForFlatConfig(
 						sourceCode,
-						ruleId => getRuleFromConfig(ruleId, config),
+						ruleId => config.getRuleDefinition(ruleId),
 						config.language,
 					)
 				: { problems: [], disableDirectives: [] };
@@ -2289,7 +2282,7 @@ class Linter {
 			lintingProblems = runRules(
 				sourceCode,
 				configuredRules,
-				ruleId => getRuleFromConfig(ruleId, config),
+				ruleId => config.getRuleDefinition(ruleId),
 				void 0,
 				config.language,
 				languageOptions,
@@ -2348,7 +2341,7 @@ class Linter {
 	/**
 	 * Same as linter.verify, except without support for processors.
 	 * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
-	 * @param {FlatConfig} providedConfig An ESLintConfig instance to configure everything.
+	 * @param {Config} providedConfig An ESLintConfig instance to configure everything.
 	 * @param {VerifyOptions} [providedOptions] The optional filename of the file being checked.
 	 * @throws {Error} If during rule execution.
 	 * @returns {(LintMessage|SuppressedLintMessage)[]} The results as an array of messages or an empty array if no messages.
@@ -2619,7 +2612,7 @@ class Linter {
 
 	/**
 	 * Gets the times spent on (parsing, fixing, linting) a file.
-	 * @returns {LintTimes} The times.
+	 * @returns {{ passes: TimePass[]; }} The times.
 	 */
 	getTimes() {
 		return internalSlotsMap.get(this).times ?? { passes: [] };

package/lib/linter/report-translator.js

@@ -17,7 +17,8 @@ const { interpolate } = require("./interpolate");
 // Typedefs
 //------------------------------------------------------------------------------
 
-/** @typedef {import("../shared/types").LintMessage} LintMessage */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../types").Linter.LintSuggestion} SuggestionResult */
 
 /**
  * An error message description

package/lib/rule-tester/rule-tester.js

@@ -15,7 +15,7 @@ const assert = require("node:assert"),
 	path = require("node:path"),
 	equal = require("fast-deep-equal"),
 	Traverser = require("../shared/traverser"),
-	{ getRuleOptionsSchema } = require("../config/flat-config-helpers"),
+	{ Config } = require("../config/config"),
 	{ Linter, SourceCodeFixer } = require("../linter"),
 	{ interpolate, getPlaceholderMatcher } = require("../linter/interpolate"),
 	stringify = require("json-stable-stringify-without-jsonify");
@@ -41,7 +41,7 @@ const { SourceCode } = require("../languages/js/source-code");
 
 /** @import { LanguageOptions, RuleDefinition } from "@eslint/core" */
 
-/** @typedef {import("../shared/types").Parser} Parser */
+/** @typedef {import("../types").Linter.Parser} Parser */
 
 /**
  * A test case that is expected to pass lint.
@@ -767,7 +767,7 @@ class RuleTester {
 			let schema;
 
 			try {
-				schema = getRuleOptionsSchema(rule);
+				schema = Config.getRuleOptionsSchema(rule);
 			} catch (err) {
 				err.message += metaSchemaDescription;
 				throw err;

package/lib/rules/index.js

@@ -225,6 +225,7 @@ module.exports = new LazyLoadingRuleMap(
 		"no-this-before-super": () => require("./no-this-before-super"),
 		"no-throw-literal": () => require("./no-throw-literal"),
 		"no-trailing-spaces": () => require("./no-trailing-spaces"),
+		"no-unassigned-vars": () => require("./no-unassigned-vars"),
 		"no-undef": () => require("./no-undef"),
 		"no-undef-init": () => require("./no-undef-init"),
 		"no-undefined": () => require("./no-undefined"),

package/lib/rules/max-params.js

@@ -20,6 +20,8 @@ const { upperCaseFirst } = require("../shared/string-utils");
 module.exports = {
 	meta: {
 		type: "suggestion",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
 
 		docs: {
 			description:
@@ -46,6 +48,11 @@ module.exports = {
 								type: "integer",
 								minimum: 0,
 							},
+							countVoidThis: {
+								type: "boolean",
+								description:
+									"Whether to count a `this` declaration when the type is `void`.",
+							},
 						},
 						additionalProperties: false,
 					},
@@ -61,12 +68,16 @@ module.exports = {
 		const sourceCode = context.sourceCode;
 		const option = context.options[0];
 		let numParams = 3;
+		let countVoidThis = false;
 
-		if (
-			typeof option === "object" &&
-			(Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max"))
-		) {
-			numParams = option.maximum || option.max;
+		if (typeof option === "object") {
+			if (
+				Object.hasOwn(option, "maximum") ||
+				Object.hasOwn(option, "max")
+			) {
+				numParams = option.maximum || option.max;
+			}
+			countVoidThis = option.countVoidThis;
 		}
 		if (typeof option === "number") {
 			numParams = option;
@@ -79,7 +90,19 @@ module.exports = {
 		 * @private
 		 */
 		function checkFunction(node) {
-			if (node.params.length > numParams) {
+			const hasVoidThisParam =
+				node.params.length > 0 &&
+				node.params[0].type === "Identifier" &&
+				node.params[0].name === "this" &&
+				node.params[0].typeAnnotation?.typeAnnotation.type ===
+					"TSVoidKeyword";
+
+			const effectiveParamCount =
+				hasVoidThisParam && !countVoidThis
+					? node.params.length - 1
+					: node.params.length;
+
+			if (effectiveParamCount > numParams) {
 				context.report({
 					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
 					node,
@@ -88,7 +111,7 @@ module.exports = {
 						name: upperCaseFirst(
 							astUtils.getFunctionNameWithKind(node),
 						),
-						count: node.params.length,
+						count: effectiveParamCount,
 						max: numParams,
 					},
 				});
@@ -99,6 +122,8 @@ module.exports = {
 			FunctionDeclaration: checkFunction,
 			ArrowFunctionExpression: checkFunction,
 			FunctionExpression: checkFunction,
+			TSDeclareFunction: checkFunction,
+			TSFunctionType: checkFunction,
 		};
 	},
 };