eslint 9.32.0 → 9.34.0

package/lib/rules/one-var.js

@@ -64,6 +64,12 @@ module.exports = {
 							const: {
 								enum: ["always", "never", "consecutive"],
 							},
+							using: {
+								enum: ["always", "never", "consecutive"],
+							},
+							awaitUsing: {
+								enum: ["always", "never", "consecutive"],
+							},
 						},
 						additionalProperties: false,
 					},
@@ -112,6 +118,8 @@ module.exports = {
 			options.var = { uninitialized: mode, initialized: mode };
 			options.let = { uninitialized: mode, initialized: mode };
 			options.const = { uninitialized: mode, initialized: mode };
+			options.using = { uninitialized: mode, initialized: mode };
+			options.awaitUsing = { uninitialized: mode, initialized: mode };
 		} else if (typeof mode === "object") {
 			// options configuration is an object
 			options.separateRequires = !!mode.separateRequires;
@@ -121,15 +129,27 @@ module.exports = {
 				uninitialized: mode.const,
 				initialized: mode.const,
 			};
+			options.using = {
+				uninitialized: mode.using,
+				initialized: mode.using,
+			};
+			options.awaitUsing = {
+				uninitialized: mode.awaitUsing,
+				initialized: mode.awaitUsing,
+			};
 			if (Object.hasOwn(mode, "uninitialized")) {
 				options.var.uninitialized = mode.uninitialized;
 				options.let.uninitialized = mode.uninitialized;
 				options.const.uninitialized = mode.uninitialized;
+				options.using.uninitialized = mode.uninitialized;
+				options.awaitUsing.uninitialized = mode.uninitialized;
 			}
 			if (Object.hasOwn(mode, "initialized")) {
 				options.var.initialized = mode.initialized;
 				options.let.initialized = mode.initialized;
 				options.const.initialized = mode.initialized;
+				options.using.initialized = mode.initialized;
+				options.awaitUsing.initialized = mode.initialized;
 			}
 		}
 
@@ -151,6 +171,8 @@ module.exports = {
 			blockStack.push({
 				let: { initialized: false, uninitialized: false },
 				const: { initialized: false, uninitialized: false },
+				using: { initialized: false, uninitialized: false },
+				awaitUsing: { initialized: false, uninitialized: false },
 			});
 		}
 
@@ -199,7 +221,7 @@ module.exports = {
 
 		/**
 		 * Records whether initialized/uninitialized/required variables are defined in current scope.
-		 * @param {string} statementType node.kind, one of: "var", "let", or "const"
+		 * @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing"
 		 * @param {ASTNode[]} declarations List of declarations
 		 * @param {Object} currentScope The scope being investigated
 		 * @returns {void}
@@ -234,7 +256,7 @@ module.exports = {
 
 		/**
 		 * Determines the current scope (function or block)
-		 * @param {string} statementType node.kind, one of: "var", "let", or "const"
+		 * @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing"
 		 * @returns {Object} The scope associated with statementType
 		 */
 		function getCurrentScope(statementType) {
@@ -246,6 +268,10 @@ module.exports = {
 				currentScope = blockStack.at(-1).let;
 			} else if (statementType === "const") {
 				currentScope = blockStack.at(-1).const;
+			} else if (statementType === "using") {
+				currentScope = blockStack.at(-1).using;
+			} else if (statementType === "awaitUsing") {
+				currentScope = blockStack.at(-1).awaitUsing;
 			}
 			return currentScope;
 		}
@@ -271,7 +297,7 @@ module.exports = {
 
 		/**
 		 * Determines if there is more than one var statement in the current scope.
-		 * @param {string} statementType node.kind, one of: "var", "let", or "const"
+		 * @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing"
 		 * @param {ASTNode[]} declarations List of declarations
 		 * @returns {boolean} Returns true if it is the first var declaration, false if not.
 		 * @private
@@ -333,24 +359,27 @@ module.exports = {
 			);
 			const previousNode = body[currentIndex - 1];
 
-			return fixer => {
-				const type = sourceCode.getTokenBefore(declaration);
-				const prevSemi = sourceCode.getTokenBefore(type);
-				const res = [];
+			return function* joinDeclarationsFixer(fixer) {
+				const type = sourceCode.getFirstToken(declaration.parent);
+				const beforeType = sourceCode.getTokenBefore(type);
 
 				if (
 					previousNode &&
-					previousNode.kind === sourceCode.getText(type)
+					previousNode.kind === declaration.parent.kind
 				) {
-					if (prevSemi.value === ";") {
-						res.push(fixer.replaceText(prevSemi, ","));
+					if (beforeType.value === ";") {
+						yield fixer.replaceText(beforeType, ",");
 					} else {
-						res.push(fixer.insertTextAfter(prevSemi, ","));
+						yield fixer.insertTextAfter(beforeType, ",");
+					}
+
+					if (declaration.parent.kind === "await using") {
+						const usingToken = sourceCode.getTokenAfter(type);
+						yield fixer.remove(usingToken);
 					}
-					res.push(fixer.replaceText(type, ""));
-				}
 
-				return res;
+					yield fixer.replaceText(type, "");
+				}
 			};
 		}
 
@@ -440,7 +469,10 @@ module.exports = {
 									tokenAfterDeclarator.range[0],
 									lastComment.range[0],
 								],
-								`;${sourceCode.text.slice(tokenAfterDeclarator.range[1], lastComment.range[0])}${exportPlacement}${declaration.kind} `,
+								`;${sourceCode.text.slice(
+									tokenAfterDeclarator.range[1],
+									lastComment.range[0],
+								)}${exportPlacement}${declaration.kind} `,
 							);
 						}
 
@@ -461,8 +493,9 @@ module.exports = {
 		function checkVariableDeclaration(node) {
 			const parent = node.parent;
 			const type = node.kind;
+			const key = type === "await using" ? "awaitUsing" : type;
 
-			if (!options[type]) {
+			if (!options[key]) {
 				return;
 			}
 
@@ -471,7 +504,7 @@ module.exports = {
 			const mixedRequires =
 				declarations.some(isRequire) && !declarations.every(isRequire);
 
-			if (options[type].initialized === MODE_ALWAYS) {
+			if (options[key].initialized === MODE_ALWAYS) {
 				if (options.separateRequires && mixedRequires) {
 					context.report({
 						node,
@@ -508,8 +541,8 @@ module.exports = {
 					);
 
 					if (
-						options[type].initialized === MODE_CONSECUTIVE &&
-						options[type].uninitialized === MODE_CONSECUTIVE
+						options[key].initialized === MODE_CONSECUTIVE &&
+						options[key].uninitialized === MODE_CONSECUTIVE
 					) {
 						context.report({
 							node,
@@ -520,7 +553,7 @@ module.exports = {
 							fix: joinDeclarations(declarations),
 						});
 					} else if (
-						options[type].initialized === MODE_CONSECUTIVE &&
+						options[key].initialized === MODE_CONSECUTIVE &&
 						declarationCounts.initialized > 0 &&
 						previousDeclCounts.initialized > 0
 					) {
@@ -533,7 +566,7 @@ module.exports = {
 							fix: joinDeclarations(declarations),
 						});
 					} else if (
-						options[type].uninitialized === MODE_CONSECUTIVE &&
+						options[key].uninitialized === MODE_CONSECUTIVE &&
 						declarationCounts.uninitialized > 0 &&
 						previousDeclCounts.uninitialized > 0
 					) {
@@ -550,10 +583,10 @@ module.exports = {
 			}
 
 			// always
-			if (!hasOnlyOneStatement(type, declarations)) {
+			if (!hasOnlyOneStatement(key, declarations)) {
 				if (
-					options[type].initialized === MODE_ALWAYS &&
-					options[type].uninitialized === MODE_ALWAYS
+					options[key].initialized === MODE_ALWAYS &&
+					options[key].uninitialized === MODE_ALWAYS
 				) {
 					context.report({
 						node,
@@ -565,7 +598,7 @@ module.exports = {
 					});
 				} else {
 					if (
-						options[type].initialized === MODE_ALWAYS &&
+						options[key].initialized === MODE_ALWAYS &&
 						declarationCounts.initialized > 0
 					) {
 						context.report({
@@ -578,7 +611,7 @@ module.exports = {
 						});
 					}
 					if (
-						options[type].uninitialized === MODE_ALWAYS &&
+						options[key].uninitialized === MODE_ALWAYS &&
 						declarationCounts.uninitialized > 0
 					) {
 						if (
@@ -608,8 +641,8 @@ module.exports = {
 
 				if (totalDeclarations > 1) {
 					if (
-						options[type].initialized === MODE_NEVER &&
-						options[type].uninitialized === MODE_NEVER
+						options[key].initialized === MODE_NEVER &&
+						options[key].uninitialized === MODE_NEVER
 					) {
 						// both initialized and uninitialized
 						context.report({
@@ -621,7 +654,7 @@ module.exports = {
 							fix: splitDeclarations(node),
 						});
 					} else if (
-						options[type].initialized === MODE_NEVER &&
+						options[key].initialized === MODE_NEVER &&
 						declarationCounts.initialized > 0
 					) {
 						// initialized
@@ -634,7 +667,7 @@ module.exports = {
 							fix: splitDeclarations(node),
 						});
 					} else if (
-						options[type].uninitialized === MODE_NEVER &&
+						options[key].uninitialized === MODE_NEVER &&
 						declarationCounts.uninitialized > 0
 					) {
 						// uninitialized

package/lib/rules/prefer-regex-literals.js

@@ -522,7 +522,7 @@ module.exports = {
 						}
 
 						if (
-							!/^[-a-zA-Z0-9\\[\](){} \t\r\n\v\f!@#$%^&*+^_=/~`.><?,'"|:;]*$/u.test(
+							!/^[-\w\\[\](){} \t\r\n\v\f!@#$%^&*+=/~`.><?,'"|:;]*$/u.test(
 								regexContent,
 							)
 						) {

package/lib/rules/utils/ast-utils.js

@@ -58,7 +58,7 @@ const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u;
 
 // Tests the presence of at least one LegacyOctalEscapeSequence or NonOctalDecimalEscapeSequence in a raw string
 const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN =
-	/^(?:[^\\]|\\.)*\\(?:[1-9]|0[0-9])/su;
+	/^(?:[^\\]|\\.)*\\(?:[1-9]|0\d)/su;
 
 const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]);
 

package/lib/rules/utils/char-source.js

@@ -85,7 +85,7 @@ function readHexSequence(reader, length) {
  * @returns {string} A code unit.
  */
 function readUnicodeSequence(reader) {
-	const regExp = /\{(?<hexDigits>[\dA-Fa-f]+)\}/uy;
+	const regExp = /\{(?<hexDigits>[\dA-F]+)\}/iuy;
 
 	regExp.lastIndex = reader.pos;
 	const match = regExp.exec(reader.source);

package/lib/rules/yoda.js

@@ -20,7 +20,7 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} Whether or not it is a comparison operator.
  */
 function isComparisonOperator(operator) {
-	return /^(==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
+	return /^(?:==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
 }
 
 /**
@@ -29,7 +29,7 @@ function isComparisonOperator(operator) {
  * @returns {boolean} Whether or not it is an equality operator.
  */
 function isEqualityOperator(operator) {
-	return /^(==|===)$/u.test(operator);
+	return /^(?:==|===)$/u.test(operator);
 }
 
 /**

package/lib/services/warning-service.js

@@ -80,6 +80,19 @@ class WarningService {
 	emitInactiveFlagWarning(flag, message) {
 		this.emitWarning(message, `ESLintInactiveFlag_${flag}`);
 	}
+
+	/**
+	 * Emits a warning when a suboptimal concurrency setting is detected.
+	 * Currently, this is only used to warn when the net linting ratio is low.
+	 * @param {string} notice A notice about how to improve performance.
+	 * @returns {void}
+	 */
+	emitPoorConcurrencyWarning(notice) {
+		this.emitWarning(
+			`You may ${notice} to improve performance.`,
+			"ESLintPoorConcurrencyWarning",
+		);
+	}
 }
 
 module.exports = { WarningService };

package/lib/shared/naming.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-const NAMESPACE_REGEX = /^@.*\//iu;
+const NAMESPACE_REGEX = /^@.*\//u;
 
 /**
  * Brings package name to correct format based on prefix

package/lib/shared/translate-cli-options.js

@@ -0,0 +1,281 @@
+/**
+ * @fileoverview Translates CLI options into ESLint constructor options.
+ * @author Nicholas C. Zakas
+ * @author Francesco Trotta
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { normalizeSeverityToString } = require("./severity");
+const { getShorthandName, normalizePackageName } = require("./naming");
+const { ModuleImporter } = require("@humanwhocodes/module-importer");
+
+//------------------------------------------------------------------------------
+// Types
+//------------------------------------------------------------------------------
+
+/** @typedef {import("../types").ESLint.Options} ESLintOptions */
+/** @typedef {import("../types").ESLint.LegacyOptions} LegacyESLintOptions */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../options").ParsedCLIOptions} ParsedCLIOptions */
+/** @typedef {import("../types").ESLint.Plugin} Plugin */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Loads plugins with the specified names.
+ * @param {{ "import": (name: string) => Promise<any> }} importer An object with an `import` method called once for each plugin.
+ * @param {string[]} pluginNames The names of the plugins to be loaded, with or without the "eslint-plugin-" prefix.
+ * @returns {Promise<Record<string, Plugin>>} A mapping of plugin short names to implementations.
+ */
+async function loadPlugins(importer, pluginNames) {
+	const plugins = {};
+
+	await Promise.all(
+		pluginNames.map(async pluginName => {
+			const longName = normalizePackageName(pluginName, "eslint-plugin");
+			const module = await importer.import(longName);
+
+			if (!("default" in module)) {
+				throw new Error(
+					`"${longName}" cannot be used with the \`--plugin\` option because its default module does not provide a \`default\` export`,
+				);
+			}
+
+			const shortName = getShorthandName(pluginName, "eslint-plugin");
+
+			plugins[shortName] = module.default;
+		}),
+	);
+
+	return plugins;
+}
+
+/**
+ * Predicate function for whether or not to apply fixes in quiet mode.
+ * If a message is a warning, do not apply a fix.
+ * @param {LintMessage} message The lint result.
+ * @returns {boolean} True if the lint message is an error (and thus should be
+ * autofixed), false otherwise.
+ */
+function quietFixPredicate(message) {
+	return message.severity === 2;
+}
+
+/**
+ * Predicate function for whether or not to run a rule in quiet mode.
+ * If a rule is set to warning, do not run it.
+ * @param {{ ruleId: string; severity: number; }} rule The rule id and severity.
+ * @returns {boolean} True if the lint rule should run, false otherwise.
+ */
+function quietRuleFilter(rule) {
+	return rule.severity === 2;
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * Translates the CLI options into the options expected by the ESLint constructor.
+ * @param {ParsedCLIOptions} cliOptions The CLI options to translate.
+ * @param {"flat"|"eslintrc"} [configType="eslintrc"] The format of the config to generate.
+ * @returns {Promise<ESLintOptions | LegacyESLintOptions>} The options object for the ESLint constructor.
+ */
+async function translateOptions(
+	{
+		cache,
+		cacheFile,
+		cacheLocation,
+		cacheStrategy,
+		concurrency,
+		config,
+		configLookup,
+		env,
+		errorOnUnmatchedPattern,
+		eslintrc,
+		ext,
+		fix,
+		fixDryRun,
+		fixType,
+		flag,
+		global,
+		ignore,
+		ignorePath,
+		ignorePattern,
+		inlineConfig,
+		parser,
+		parserOptions,
+		plugin,
+		quiet,
+		reportUnusedDisableDirectives,
+		reportUnusedDisableDirectivesSeverity,
+		reportUnusedInlineConfigs,
+		resolvePluginsRelativeTo,
+		rule,
+		rulesdir,
+		stats,
+		warnIgnored,
+		passOnNoPatterns,
+		maxWarnings,
+	},
+	configType,
+) {
+	let overrideConfig, overrideConfigFile;
+	const importer = new ModuleImporter();
+
+	if (configType === "flat") {
+		overrideConfigFile =
+			typeof config === "string" ? config : !configLookup;
+		if (overrideConfigFile === false) {
+			overrideConfigFile = void 0;
+		}
+
+		const languageOptions = {};
+
+		if (global) {
+			languageOptions.globals = global.reduce((obj, name) => {
+				if (name.endsWith(":true")) {
+					obj[name.slice(0, -5)] = "writable";
+				} else {
+					obj[name] = "readonly";
+				}
+				return obj;
+			}, {});
+		}
+
+		if (parserOptions) {
+			languageOptions.parserOptions = parserOptions;
+		}
+
+		if (parser) {
+			languageOptions.parser = await importer.import(parser);
+		}
+
+		overrideConfig = [
+			{
+				...(Object.keys(languageOptions).length > 0
+					? { languageOptions }
+					: {}),
+				rules: rule ? rule : {},
+			},
+		];
+
+		if (
+			reportUnusedDisableDirectives ||
+			reportUnusedDisableDirectivesSeverity !== void 0
+		) {
+			overrideConfig[0].linterOptions = {
+				reportUnusedDisableDirectives: reportUnusedDisableDirectives
+					? "error"
+					: normalizeSeverityToString(
+							reportUnusedDisableDirectivesSeverity,
+						),
+			};
+		}
+
+		if (reportUnusedInlineConfigs !== void 0) {
+			overrideConfig[0].linterOptions = {
+				...overrideConfig[0].linterOptions,
+				reportUnusedInlineConfigs: normalizeSeverityToString(
+					reportUnusedInlineConfigs,
+				),
+			};
+		}
+
+		if (plugin) {
+			overrideConfig[0].plugins = await loadPlugins(importer, plugin);
+		}
+
+		if (ext) {
+			overrideConfig.push({
+				files: ext.map(
+					extension =>
+						`**/*${extension.startsWith(".") ? "" : "."}${extension}`,
+				),
+			});
+		}
+	} else {
+		overrideConfigFile = config;
+
+		overrideConfig = {
+			env:
+				env &&
+				env.reduce((obj, name) => {
+					obj[name] = true;
+					return obj;
+				}, {}),
+			globals:
+				global &&
+				global.reduce((obj, name) => {
+					if (name.endsWith(":true")) {
+						obj[name.slice(0, -5)] = "writable";
+					} else {
+						obj[name] = "readonly";
+					}
+					return obj;
+				}, {}),
+			ignorePatterns: ignorePattern,
+			parser,
+			parserOptions,
+			plugins: plugin,
+			rules: rule,
+		};
+	}
+
+	const options = {
+		allowInlineConfig: inlineConfig,
+		cache,
+		cacheLocation: cacheLocation || cacheFile,
+		cacheStrategy,
+		errorOnUnmatchedPattern,
+		fix: (fix || fixDryRun) && (quiet ? quietFixPredicate : true),
+		fixTypes: fixType,
+		ignore,
+		overrideConfig,
+		overrideConfigFile,
+		passOnNoPatterns,
+	};
+
+	if (configType === "flat") {
+		options.concurrency = concurrency;
+		options.flags = flag;
+		options.ignorePatterns = ignorePattern;
+		options.stats = stats;
+		options.warnIgnored = warnIgnored;
+
+		/*
+		 * For performance reasons rules not marked as 'error' are filtered out in quiet mode. As maxWarnings
+		 * requires rules set to 'warn' to be run, we only filter out 'warn' rules if maxWarnings is not specified.
+		 */
+		options.ruleFilter =
+			quiet && maxWarnings === -1 ? quietRuleFilter : () => true;
+	} else {
+		options.resolvePluginsRelativeTo = resolvePluginsRelativeTo;
+		options.rulePaths = rulesdir;
+		options.useEslintrc = eslintrc;
+		options.extensions = ext;
+		options.ignorePath = ignorePath;
+		if (
+			reportUnusedDisableDirectives ||
+			reportUnusedDisableDirectivesSeverity !== void 0
+		) {
+			options.reportUnusedDisableDirectives =
+				reportUnusedDisableDirectives
+					? "error"
+					: normalizeSeverityToString(
+							reportUnusedDisableDirectivesSeverity,
+						);
+		}
+	}
+
+	return options;
+}
+
+module.exports = translateOptions;

package/lib/types/index.d.ts

@@ -1966,6 +1966,10 @@ export class ESLint {
 	isPathIgnored(filePath: string): Promise<boolean>;
 
 	loadFormatter(nameOrPath?: string): Promise<ESLint.LoadedFormatter>;
+
+	static fromOptionsModule(optionsURL: {
+		readonly href: string;
+	}): Promise<ESLint>;
 }
 
 export namespace ESLint {
@@ -2047,6 +2051,7 @@ export namespace ESLint {
 		cacheStrategy?: CacheStrategy | undefined;
 
 		// Other Options
+		concurrency?: number | "auto" | "off" | undefined;
 		flags?: string[] | undefined;
 	}
 

package/lib/types/rules.d.ts

@@ -117,7 +117,7 @@ export interface ESLintRules extends Linter.RulesRecord {
 				 */
 				enforceForClassMembers: boolean;
 				/**
-				 * @default true
+				 * @default false
 				 */
 				enforceForTSTypes: boolean;
 			}>,
@@ -3403,13 +3403,26 @@ export interface ESLintRules extends Linter.RulesRecord {
 	 */
 	"no-restricted-globals": Linter.RuleEntry<
 		[
-			...Array<
-				| string
-				| {
-						name: string;
-						message?: string | undefined;
-				  }
-			>,
+			...(
+				| Array<
+						| string
+						| {
+								name: string;
+								message?: string | undefined;
+						  }
+				  >
+				| Array<{
+						globals: Array<
+							| string
+							| {
+									name: string;
+									message?: string | undefined;
+							  }
+						>;
+						checkGlobalObject?: boolean;
+						globalObjects?: string[];
+				  }>
+			),
 		]
 	>;
 
@@ -4509,7 +4522,7 @@ export interface ESLintRules extends Linter.RulesRecord {
 						 */
 						separateRequires: boolean;
 					} & Record<
-						"var" | "let" | "const",
+						"var" | "let" | "const" | "using" | "awaitUsing",
 						"always" | "never" | "consecutive"
 					>
 			  >