eslint-plugin-unicorn 55.0.0 → 56.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "55.0.0",
+	"version": "56.0.1",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -23,6 +23,7 @@
 		"fix:eslint-docs": "eslint-doc-generator",
 		"fix:js": "npm run lint:js -- --fix",
 		"fix:markdown": "npm run lint:markdown -- --fix",
+		"fix:snapshots": "ava --update-snapshots",
 		"integration": "node ./test/integration/test.mjs",
 		"lint": "run-p --continue-on-error lint:*",
 		"lint:eslint-docs": "npm run fix:eslint-docs -- --check",
@@ -51,13 +52,13 @@
 		"xo"
 	],
 	"dependencies": {
-		"@babel/helper-validator-identifier": "^7.24.5",
+		"@babel/helper-validator-identifier": "^7.24.7",
 		"@eslint-community/eslint-utils": "^4.4.0",
 		"ci-info": "^4.0.0",
 		"clean-regexp": "^1.0.0",
-		"core-js-compat": "^3.37.0",
-		"esquery": "^1.5.0",
-		"globals": "^15.7.0",
+		"core-js-compat": "^3.38.1",
+		"esquery": "^1.6.0",
+		"globals": "^15.9.0",
 		"indent-string": "^4.0.0",
 		"is-builtin-module": "^3.2.1",
 		"jsesc": "^3.0.2",
@@ -65,41 +66,41 @@
 		"read-pkg-up": "^7.0.1",
 		"regexp-tree": "^0.1.27",
 		"regjsparser": "^0.10.0",
-		"semver": "^7.6.1",
+		"semver": "^7.6.3",
 		"strip-indent": "^3.0.0"
 	},
 	"devDependencies": {
-		"@babel/code-frame": "^7.24.2",
-		"@babel/core": "^7.24.5",
-		"@babel/eslint-parser": "^7.24.5",
+		"@babel/code-frame": "^7.24.7",
+		"@babel/core": "^7.25.2",
+		"@babel/eslint-parser": "^7.25.1",
 		"@eslint/eslintrc": "^3.1.0",
 		"@lubien/fixture-beta-package": "^1.0.0-beta.1",
-		"@typescript-eslint/parser": "^8.0.0-alpha.12",
+		"@typescript-eslint/parser": "^8.4.0",
 		"ava": "^6.1.3",
-		"c8": "^9.1.0",
+		"c8": "^10.1.2",
 		"chalk": "^5.3.0",
 		"enquirer": "^2.4.1",
-		"eslint": "^9.6.0",
+		"eslint": "^9.10.0",
 		"eslint-ava-rule-tester": "^5.0.1",
 		"eslint-doc-generator": "1.7.0",
-		"eslint-plugin-eslint-plugin": "^6.1.0",
+		"eslint-plugin-eslint-plugin": "^6.2.0",
 		"eslint-plugin-internal-rules": "file:./scripts/internal-rules/",
-		"eslint-remote-tester": "^4.0.0",
+		"eslint-remote-tester": "^4.0.1",
 		"eslint-remote-tester-repositories": "^2.0.0",
-		"espree": "^10.0.1",
+		"espree": "^10.1.0",
 		"execa": "^8.0.1",
 		"listr": "^0.14.3",
 		"lodash-es": "^4.17.21",
-		"markdownlint-cli": "^0.40.0",
+		"markdownlint-cli": "^0.41.0",
 		"memoize": "^10.0.0",
-		"npm-package-json-lint": "^7.1.0",
-		"npm-run-all2": "^6.1.2",
+		"npm-package-json-lint": "^8.0.0",
+		"npm-run-all2": "^6.2.2",
 		"outdent": "^0.8.0",
-		"pretty-ms": "^9.0.0",
-		"typescript": "^5.4.5",
-		"vue-eslint-parser": "^9.4.2",
-		"xo": "^0.58.0",
-		"yaml": "^2.4.2"
+		"pretty-ms": "^9.1.0",
+		"typescript": "^5.5.4",
+		"vue-eslint-parser": "^9.4.3",
+		"xo": "^0.59.3",
+		"yaml": "^2.5.1"
 	},
 	"peerDependencies": {
 		"eslint": ">=8.56.0"
@@ -175,7 +176,8 @@
 					],
 					"eslint-plugin/require-meta-docs-url": "off",
 					"eslint-plugin/require-meta-has-suggestions": "off",
-					"eslint-plugin/require-meta-schema": "off"
+					"eslint-plugin/require-meta-schema": "off",
+					"eslint-plugin/require-meta-schema-description": "off"
 				}
 			}
 		]

package/readme.md

@@ -72,7 +72,7 @@ module.exports = [
 
 ## Usage (legacy: `.eslintrc.*` or `package.json`)
 
-Use a [preset config](#preset-configs-eslintrc-or-packagejson) or configure each rule in `package.json`.
+Use a [preset config](#legacy-preset-configs-eslintrc-or-packagejson) or configure each rule in `package.json`.
 
 If you don't use the preset, ensure you use the same `env` and `parserOptions` config as below.
 
@@ -110,10 +110,11 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 
 | Name                                                                                             | Description                                                                                                                                                                                                       | 💼 | 🔧 | 💡 |
 | :----------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- |
-| [better-regex](docs/rules/better-regex.md)                                                       | Improve regexes by making them shorter, consistent, and safer.                                                                                                                                                    | ✅  | 🔧 |    |
+| [better-regex](docs/rules/better-regex.md)                                                       | Improve regexes by making them shorter, consistent, and safer.                                                                                                                                                    |    | 🔧 |    |
 | [catch-error-name](docs/rules/catch-error-name.md)                                               | Enforce a specific parameter name in catch clauses.                                                                                                                                                               | ✅  | 🔧 |    |
 | [consistent-destructuring](docs/rules/consistent-destructuring.md)                               | Use destructured variables over properties.                                                                                                                                                                       |    | 🔧 | 💡 |
 | [consistent-empty-array-spread](docs/rules/consistent-empty-array-spread.md)                     | Prefer consistent types when spreading a ternary in an array literal.                                                                                                                                             | ✅  | 🔧 |    |
+| [consistent-existence-index-check](docs/rules/consistent-existence-index-check.md)               | Enforce consistent style for element existence checks with `indexOf()`, `lastIndexOf()`, `findIndex()`, and `findLastIndex()`.                                                                                    | ✅  | 🔧 |    |
 | [consistent-function-scoping](docs/rules/consistent-function-scoping.md)                         | Move function definitions to the highest possible scope.                                                                                                                                                          | ✅  |    |    |
 | [custom-error-definition](docs/rules/custom-error-definition.md)                                 | Enforce correct `Error` subclassing.                                                                                                                                                                              |    | 🔧 |    |
 | [empty-brace-spaces](docs/rules/empty-brace-spaces.md)                                           | Enforce no spaces between braces.                                                                                                                                                                                 | ✅  | 🔧 |    |
@@ -189,10 +190,12 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | [prefer-dom-node-text-content](docs/rules/prefer-dom-node-text-content.md)                       | Prefer `.textContent` over `.innerText`.                                                                                                                                                                          | ✅  |    | 💡 |
 | [prefer-event-target](docs/rules/prefer-event-target.md)                                         | Prefer `EventTarget` over `EventEmitter`.                                                                                                                                                                         | ✅  |    |    |
 | [prefer-export-from](docs/rules/prefer-export-from.md)                                           | Prefer `export…from` when re-exporting.                                                                                                                                                                           | ✅  | 🔧 | 💡 |
+| [prefer-global-this](docs/rules/prefer-global-this.md)                                           | Prefer `globalThis` over `window`, `self`, and `global`.                                                                                                                                                          | ✅  | 🔧 |    |
 | [prefer-includes](docs/rules/prefer-includes.md)                                                 | Prefer `.includes()` over `.indexOf()`, `.lastIndexOf()`, and `Array#some()` when checking for existence or non-existence.                                                                                        | ✅  | 🔧 | 💡 |
 | [prefer-json-parse-buffer](docs/rules/prefer-json-parse-buffer.md)                               | Prefer reading a JSON file as a buffer.                                                                                                                                                                           |    | 🔧 |    |
 | [prefer-keyboard-event-key](docs/rules/prefer-keyboard-event-key.md)                             | Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`.                                                                                                                                                          | ✅  | 🔧 |    |
 | [prefer-logical-operator-over-ternary](docs/rules/prefer-logical-operator-over-ternary.md)       | Prefer using a logical operator over a ternary.                                                                                                                                                                   | ✅  |    | 💡 |
+| [prefer-math-min-max](docs/rules/prefer-math-min-max.md)                                         | Prefer `Math.min()` and `Math.max()` over ternaries for simple comparisons.                                                                                                                                       | ✅  | 🔧 |    |
 | [prefer-math-trunc](docs/rules/prefer-math-trunc.md)                                             | Enforce the use of `Math.trunc` instead of bitwise operators.                                                                                                                                                     | ✅  | 🔧 | 💡 |
 | [prefer-modern-dom-apis](docs/rules/prefer-modern-dom-apis.md)                                   | Prefer `.before()` over `.insertBefore()`, `.replaceWith()` over `.replaceChild()`, prefer one of `.before()`, `.after()`, `.append()` or `.prepend()` over `insertAdjacentText()` and `insertAdjacentElement()`. | ✅  | 🔧 |    |
 | [prefer-modern-math-apis](docs/rules/prefer-modern-math-apis.md)                                 | Prefer modern `Math` APIs over legacy patterns.                                                                                                                                                                   | ✅  | 🔧 |    |
@@ -204,7 +207,7 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | [prefer-object-from-entries](docs/rules/prefer-object-from-entries.md)                           | Prefer using `Object.fromEntries(…)` to transform a list of key-value pairs into an object.                                                                                                                       | ✅  | 🔧 |    |
 | [prefer-optional-catch-binding](docs/rules/prefer-optional-catch-binding.md)                     | Prefer omitting the `catch` binding parameter.                                                                                                                                                                    | ✅  | 🔧 |    |
 | [prefer-prototype-methods](docs/rules/prefer-prototype-methods.md)                               | Prefer borrowing methods from the prototype instead of the instance.                                                                                                                                              | ✅  | 🔧 |    |
-| [prefer-query-selector](docs/rules/prefer-query-selector.md)                                     | Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()`.                                                                         | ✅  | 🔧 |    |
+| [prefer-query-selector](docs/rules/prefer-query-selector.md)                                     | Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()` and `.getElementsByName()`.                                              | ✅  | 🔧 |    |
 | [prefer-reflect-apply](docs/rules/prefer-reflect-apply.md)                                       | Prefer `Reflect.apply()` over `Function#apply()`.                                                                                                                                                                 | ✅  | 🔧 |    |
 | [prefer-regexp-test](docs/rules/prefer-regexp-test.md)                                           | Prefer `RegExp#test()` over `String#match()` and `RegExp#exec()`.                                                                                                                                                 | ✅  | 🔧 | 💡 |
 | [prefer-set-has](docs/rules/prefer-set-has.md)                                                   | Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence.                                                                                                                          | ✅  | 🔧 | 💡 |
@@ -239,13 +242,13 @@ See [docs/deprecated-rules.md](docs/deprecated-rules.md)
 
 ## Preset configs (`eslint.config.js`)
 
-See the [ESLint docs](https://eslint.org/docs/latest/user-guide/configuring/configuration-files-new) for more information about extending config files.
+See the [ESLint docs](https://eslint.org/docs/latest/use/configure/configuration-files) for more information about extending config files.
 
-**Note**: Preset configs will also enable the correct [language options](https://eslint.org/docs/latest/use/configure/configuration-files-new#configuring-language-options).
+**Note**: Preset configs will also enable the correct [language options](https://eslint.org/docs/latest/use/configure/language-options).
 
 ### Recommended config
 
-This plugin exports a [`recommended` config](configs/recommended.js) that enforces good practices.
+This plugin exports a `recommended` config that enforces good practices.
 
 #### ES Module (Recommended)
 
@@ -282,7 +285,7 @@ module.exports = [
 
 ### All config
 
-This plugin exports an [`all` config](configs/all.js) that makes use of all rules (except for deprecated ones).
+This plugin exports an `all` that makes use of all rules (except for deprecated ones).
 
 #### ES Module (Recommended)
 
@@ -317,15 +320,15 @@ module.exports = [
 ];
 ```
 
-## Preset configs (`.eslintrc.*` or `package.json`)
+## Legacy preset configs (`.eslintrc.*` or `package.json`)
 
-See the [ESLint docs](https://eslint.org/docs/user-guide/configuring/configuration-files#extending-configuration-files) for more information about extending config files.
+See the [ESLint docs](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated) for more information about extending deprecated legacy config files.
 
-**Note**: Preset configs will also enable the correct [parser options](https://eslint.org/docs/user-guide/configuring/language-options#specifying-parser-options) and [environment](https://eslint.org/docs/user-guide/configuring/language-options#specifying-environments).
+**Note**: Preset configs will also enable the correct [parser options](https://eslint.org/docs/latest/use/configure/parser-deprecated) and [environment](https://eslint.org/docs/latest/use/configure/language-options-deprecated).
 
-### Recommended config
+### Recommended legacy config
 
-This plugin exports a [`recommended` config](configs/recommended.js) that enforces good practices.
+This plugin exports a `recommended` legacy config that enforces good practices.
 
 ```json
 {
@@ -339,9 +342,9 @@ This plugin exports a [`recommended` config](configs/recommended.js) that enforc
 }
 ```
 
-### All config
+### All legacy config
 
-This plugin exports an [`all` config](configs/all.js) that makes use of all rules (except for deprecated ones).
+This plugin exports an `all` legacy config that makes use of all rules (except for deprecated ones).
 
 ```json
 {

package/rules/ast/index.js

@@ -31,6 +31,7 @@ module.exports = {
 	isFunction: require('./is-function.js'),
 	isMemberExpression: require('./is-member-expression.js'),
 	isMethodCall: require('./is-method-call.js'),
+	isNegativeOne: require('./is-negative-one.js'),
 	isNewExpression,
 	isReferenceIdentifier: require('./is-reference-identifier.js'),
 	isStaticRequire: require('./is-static-require.js'),

package/rules/ast/is-negative-one.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const {isNumberLiteral} = require('./literal.js');
+
+function isNegativeOne(node) {
+	return node?.type === 'UnaryExpression'
+		&& node.operator === '-'
+		&& isNumberLiteral(node.argument)
+		&& node.argument.value === 1;
+}
+
+module.exports = isNegativeOne;

package/rules/better-regex.js

@@ -136,7 +136,7 @@ module.exports = {
 		type: 'suggestion',
 		docs: {
 			description: 'Improve regexes by making them shorter, consistent, and safer.',
-			recommended: true,
+			recommended: false,
 		},
 		fixable: 'code',
 		schema,

package/rules/consistent-existence-index-check.js

@@ -0,0 +1,133 @@
+'use strict';
+const toLocation = require('./utils/to-location.js');
+const {isMethodCall, isNegativeOne, isNumberLiteral} = require('./ast/index.js');
+
+const MESSAGE_ID = 'consistent-existence-index-check';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `{{replacementOperator}} {{replacementValue}}` over `{{originalOperator}} {{originalValue}}` to check {{existenceOrNonExistence}}.',
+};
+
+const isZero = node => isNumberLiteral(node) && node.value === 0;
+
+/**
+@param {parent: import('estree').BinaryExpression} binaryExpression
+@returns {{
+	replacementOperator: string,
+	replacementValue: string,
+	originalOperator: string,
+	originalValue: string,
+} | undefined}
+*/
+function getReplacement(binaryExpression) {
+	const {operator, right} = binaryExpression;
+
+	if (operator === '<' && isZero(right)) {
+		return {
+			replacementOperator: '===',
+			replacementValue: '-1',
+			originalOperator: operator,
+			originalValue: '0',
+		};
+	}
+
+	if (operator === '>' && isNegativeOne(right)) {
+		return {
+			replacementOperator: '!==',
+			replacementValue: '-1',
+			originalOperator: operator,
+			originalValue: '-1',
+		};
+	}
+
+	if (operator === '>=' && isZero(right)) {
+		return {
+			replacementOperator: '!==',
+			replacementValue: '-1',
+			originalOperator: operator,
+			originalValue: '0',
+		};
+	}
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	/** @param {import('estree').VariableDeclarator} variableDeclarator */
+	* VariableDeclarator(variableDeclarator) {
+		if (!(
+			variableDeclarator.parent.type === 'VariableDeclaration'
+			&& variableDeclarator.parent.kind === 'const'
+			&& variableDeclarator.id.type === 'Identifier'
+			&& isMethodCall(variableDeclarator.init, {methods: ['indexOf', 'lastIndexOf', 'findIndex', 'findLastIndex']})
+		)) {
+			return;
+		}
+
+		const variableIdentifier = variableDeclarator.id;
+		const variables = context.sourceCode.getDeclaredVariables(variableDeclarator);
+		const [variable] = variables;
+
+		// Just for safety
+		if (
+			variables.length !== 1
+			|| variable.identifiers.length !== 1
+			|| variable.identifiers[0] !== variableIdentifier
+		) {
+			return;
+		}
+
+		for (const {identifier} of variable.references) {
+			/** @type {{parent: import('estree').BinaryExpression}} */
+			const binaryExpression = identifier.parent;
+
+			if (binaryExpression.type !== 'BinaryExpression' || binaryExpression.left !== identifier) {
+				continue;
+			}
+
+			const replacement = getReplacement(binaryExpression);
+
+			if (!replacement) {
+				return;
+			}
+
+			const {left, operator, right} = binaryExpression;
+			const {sourceCode} = context;
+
+			const operatorToken = sourceCode.getTokenAfter(
+				left,
+				token => token.type === 'Punctuator' && token.value === operator,
+			);
+
+			yield {
+				node: binaryExpression,
+				loc: toLocation([operatorToken.range[0], right.range[1]], sourceCode),
+				messageId: MESSAGE_ID,
+				data: {
+					...replacement,
+					existenceOrNonExistence: `${replacement.replacementOperator === '===' ? 'non-' : ''}existence`,
+				},
+				* fix(fixer) {
+					yield fixer.replaceText(operatorToken, replacement.replacementOperator);
+
+					if (replacement.replacementValue !== replacement.originalValue) {
+						yield fixer.replaceText(right, replacement.replacementValue);
+					}
+				},
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Enforce consistent style for element existence checks with `indexOf()`, `lastIndexOf()`, `findIndex()`, and `findLastIndex()`.',
+			recommended: true,
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/expiring-todo-comments.js

@@ -271,13 +271,17 @@ function semverComparisonForOperator(operator) {
 	}[operator];
 }
 
+const DEFAULT_OPTIONS = {
+	terms: ['todo', 'fixme', 'xxx'],
+	ignore: [],
+	ignoreDatesOnPullRequests: true,
+	allowWarningComments: true,
+};
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const options = {
-		terms: ['todo', 'fixme', 'xxx'],
-		ignore: [],
-		ignoreDatesOnPullRequests: true,
-		allowWarningComments: true,
+		...DEFAULT_OPTIONS,
 		date: new Date().toISOString().slice(0, 10),
 		...context.options[0],
 	};
@@ -564,7 +568,7 @@ const schema = [
 			},
 			allowWarningComments: {
 				type: 'boolean',
-				default: false,
+				default: true,
 			},
 			date: {
 				type: 'string',
@@ -584,6 +588,7 @@ module.exports = {
 			recommended: true,
 		},
 		schema,
+		defaultOptions: [{...DEFAULT_OPTIONS}],
 		messages,
 	},
 };

package/rules/no-array-reduce.js

@@ -2,9 +2,11 @@
 const {isMethodCall} = require('./ast/index.js');
 const {isNodeValueNotFunction, isArrayPrototypeProperty} = require('./utils/index.js');
 
-const MESSAGE_ID = 'no-reduce';
+const MESSAGE_ID_REDUCE = 'reduce';
+const MESSAGE_ID_REDUCE_RIGHT = 'reduceRight';
 const messages = {
-	[MESSAGE_ID]: '`Array#{{method}}()` is not allowed',
+	[MESSAGE_ID_REDUCE]: '`Array#reduce()` is not allowed. Prefer other types of loop for readability.',
+	[MESSAGE_ID_REDUCE_RIGHT]: '`Array#reduceRight()` is not allowed. Prefer other types of loop for readability. You may want to call `Array#toReversed()` before looping it.',
 };
 
 const cases = [
@@ -104,8 +106,7 @@ const create = context => {
 				const methodNode = getMethodNode(callExpression);
 				yield {
 					node: methodNode,
-					messageId: MESSAGE_ID,
-					data: {method: methodNode.name},
+					messageId: methodNode.name,
 				};
 			}
 		},

package/rules/no-for-loop.js

@@ -263,7 +263,7 @@ const getReferencesInChildScopes = (scope, name) =>
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;
-	const {scopeManager, text: sourceCodeText} = sourceCode;
+	const {scopeManager} = sourceCode;
 
 	return {
 		ForStatement(node) {
@@ -339,12 +339,12 @@ const create = context => {
 			const elementIdentifierName = elementNode?.id.name;
 			const elementVariable = elementIdentifierName && resolveIdentifierName(elementIdentifierName, bodyScope);
 
-			const shouldFix = !someVariablesLeakOutOfTheLoop(node, [indexVariable, elementVariable].filter(Boolean), forScope);
+			const shouldFix = !someVariablesLeakOutOfTheLoop(node, [indexVariable, elementVariable].filter(Boolean), forScope)
+				&& !elementNode?.id.typeAnnotation;
 
 			if (shouldFix) {
 				problem.fix = function * (fixer) {
 					const shouldGenerateIndex = isIndexVariableUsedElsewhereInTheLoopBody(indexVariable, bodyScope, arrayIdentifierName);
-
 					const index = indexIdentifierName;
 					const element = elementIdentifierName
 						|| avoidCapture(singular(arrayIdentifierName) || defaultElementName, getScopes(bodyScope));
@@ -353,7 +353,6 @@ const create = context => {
 					let declarationElement = element;
 					let declarationType = 'const';
 					let removeDeclaration = true;
-					let typeAnnotation;
 
 					if (elementNode) {
 						if (elementNode.id.type === 'ObjectPattern' || elementNode.id.type === 'ArrayPattern') {
@@ -362,26 +361,13 @@ const create = context => {
 
 						if (removeDeclaration) {
 							declarationType = element.type === 'VariableDeclarator' ? elementNode.kind : elementNode.parent.kind;
-							if (elementNode.id.typeAnnotation && shouldGenerateIndex) {
-								declarationElement = sourceCodeText.slice(elementNode.id.range[0], elementNode.id.typeAnnotation.range[0]).trim();
-								typeAnnotation = sourceCode.getText(
-									elementNode.id.typeAnnotation,
-									-1, // Skip leading `:`
-								).trim();
-							} else {
-								declarationElement = sourceCode.getText(elementNode.id);
-							}
+							declarationElement = sourceCode.getText(elementNode.id);
 						}
 					}
 
 					const parts = [declarationType];
 					if (shouldGenerateIndex) {
-						parts.push(` [${index}, ${declarationElement}]`);
-						if (typeAnnotation) {
-							parts.push(`: [number, ${typeAnnotation}]`);
-						}
-
-						parts.push(` of ${array}.entries()`);
+						parts.push(` [${index}, ${declarationElement}] of ${array}.entries()`);
 					} else {
 						parts.push(` ${declarationElement} of ${array}`);
 					}

package/rules/no-negation-in-equality-check.js

@@ -12,7 +12,7 @@ const {
 const MESSAGE_ID_ERROR = 'no-negation-in-equality-check/error';
 const MESSAGE_ID_SUGGESTION = 'no-negation-in-equality-check/suggestion';
 const messages = {
-	[MESSAGE_ID_ERROR]: 'Negated expression in not allowed in equality check.',
+	[MESSAGE_ID_ERROR]: 'Negated expression is not allowed in equality check.',
 	[MESSAGE_ID_SUGGESTION]: 'Switch to \'{{operator}}\' check.',
 };
 

package/rules/no-new-array.js

@@ -9,7 +9,7 @@ const MESSAGE_ID_LENGTH = 'array-length';
 const MESSAGE_ID_ONLY_ELEMENT = 'only-element';
 const MESSAGE_ID_SPREAD = 'spread';
 const messages = {
-	[MESSAGE_ID_ERROR]: 'Do not use `new Array()`.',
+	[MESSAGE_ID_ERROR]: '`new Array()` is unclear in intent; use either `[x]` or `Array.from({length: x})`',
 	[MESSAGE_ID_LENGTH]: 'The argument is the length of array.',
 	[MESSAGE_ID_ONLY_ELEMENT]: 'The argument is the only element of array.',
 	[MESSAGE_ID_SPREAD]: 'Spread the argument.',

package/rules/no-useless-undefined.js

@@ -62,6 +62,8 @@ const shouldIgnore = node => {
 		|| name === 'createContext'
 		// `setState(undefined)`
 		|| /^set[A-Z]/.test(name)
+		// React 19 useRef
+		|| name === 'useRef'
 
 		// https://vuejs.org/api/reactivity-core.html#ref
 		|| name === 'ref';

package/rules/prefer-global-this.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const MESSAGE_ID_ERROR = 'prefer-global-this/error';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Prefer `globalThis` over `{{value}}`.',
+};
+
+const globalIdentifier = new Set(['window', 'self', 'global']);
+
+const windowSpecificEvents = new Set([
+	'resize',
+	'blur',
+	'focus',
+	'load',
+	'scroll',
+	'scrollend',
+	'wheel',
+	'beforeunload', // Browsers might have specific behaviors on exactly `window.onbeforeunload =`
+	'message',
+	'messageerror',
+	'pagehide',
+	'pagereveal',
+	'pageshow',
+	'pageswap',
+	'unload',
+]);
+
+/**
+Note: What kind of API should be a windows-specific interface?
+
+1. It's directly related to window (✅ window.close())
+2. It does NOT work well as globalThis.x or x (✅ window.frames, window.top)
+
+Some constructors are occasionally related to window (like Element !== iframe.contentWindow.Element), but they don't need to mention window anyway.
+
+Please use these criteria to decide whether an API should be added here. Context: https://github.com/sindresorhus/eslint-plugin-unicorn/pull/2410#discussion_r1695312427
+*/
+const windowSpecificAPIs = new Set([
+	// Properties and methods
+	// https://html.spec.whatwg.org/multipage/nav-history-apis.html#the-window-object
+	'name',
+	'locationbar',
+	'menubar',
+	'personalbar',
+	'scrollbars',
+	'statusbar',
+	'toolbar',
+	'status',
+	'close',
+	'closed',
+	'stop',
+	'focus',
+	'blur',
+	'frames',
+	'length',
+	'top',
+	'opener',
+	'parent',
+	'frameElement',
+	'open',
+	'originAgentCluster',
+	'postMessage',
+
+	// Events commonly associated with "window"
+	...[...windowSpecificEvents].map(event => `on${event}`),
+
+	// To add/remove/dispatch events that are commonly associated with "window"
+	// https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-flow
+	'addEventListener',
+	'removeEventListener',
+	'dispatchEvent',
+
+	// https://dom.spec.whatwg.org/#idl-index
+	'event', // Deprecated and quirky, best left untouched
+
+	// https://drafts.csswg.org/cssom-view/#idl-index
+	'screen',
+	'visualViewport',
+	'moveTo',
+	'moveBy',
+	'resizeTo',
+	'resizeBy',
+	'innerWidth',
+	'innerHeight',
+	'scrollX',
+	'pageXOffset',
+	'scrollY',
+	'pageYOffset',
+	'scroll',
+	'scrollTo',
+	'scrollBy',
+	'screenX',
+	'screenLeft',
+	'screenY',
+	'screenTop',
+	'screenWidth',
+	'screenHeight',
+	'devicePixelRatio',
+]);
+
+const webWorkerSpecificAPIs = new Set([
+	// https://html.spec.whatwg.org/multipage/workers.html#the-workerglobalscope-common-interface
+	'addEventListener',
+	'removeEventListener',
+	'dispatchEvent',
+
+	'self',
+	'location',
+	'navigator',
+	'onerror',
+	'onlanguagechange',
+	'onoffline',
+	'ononline',
+	'onrejectionhandled',
+	'onunhandledrejection',
+
+	// https://html.spec.whatwg.org/multipage/workers.html#dedicated-workers-and-the-dedicatedworkerglobalscope-interface
+	'name',
+	'postMessage',
+	'onconnect',
+]);
+
+/**
+Check if the node is a window-specific API.
+
+@param {import('estree').MemberExpression} node
+@returns {boolean}
+*/
+const isWindowSpecificAPI = node => {
+	if (node.type !== 'MemberExpression') {
+		return false;
+	}
+
+	if (node.object.name !== 'window' || node.property.type !== 'Identifier') {
+		return false;
+	}
+
+	if (windowSpecificAPIs.has(node.property.name)) {
+		if (['addEventListener', 'removeEventListener', 'dispatchEvent'].includes(node.property.name) && node.parent.type === 'CallExpression' && node.parent.callee === node) {
+			const argument = node.parent.arguments[0];
+			return argument && argument.type === 'Literal' && windowSpecificEvents.has(argument.value);
+		}
+
+		return true;
+	}
+
+	return false;
+};
+
+/**
+@param {import('estree').Identifier} identifier
+@returns {boolean}
+*/
+function isComputedMemberExpressionObject(identifier) {
+	return identifier.parent.type === 'MemberExpression' && identifier.parent.computed && identifier.parent.object === identifier;
+}
+
+/**
+Check if the node is a web worker specific API.
+
+@param {import('estree').MemberExpression} node
+@returns {boolean}
+*/
+const isWebWorkerSpecificAPI = node => node.type === 'MemberExpression' && node.object.name === 'self' && node.property.type === 'Identifier' && webWorkerSpecificAPIs.has(node.property.name);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	* Program(program) {
+		const scope = context.sourceCode.getScope(program);
+
+		const references = [
+			// Variables declared at globals options
+			...scope.variables.flatMap(variable => globalIdentifier.has(variable.name) ? variable.references : []),
+			// Variables not declared at globals options
+			...scope.through.filter(reference => globalIdentifier.has(reference.identifier.name)),
+		];
+
+		for (const {identifier} of references) {
+			if (
+				isComputedMemberExpressionObject(identifier)
+				|| isWindowSpecificAPI(identifier.parent)
+				|| isWebWorkerSpecificAPI(identifier.parent)
+			) {
+				continue;
+			}
+
+			yield {
+				node: identifier,
+				messageId: MESSAGE_ID_ERROR,
+				data: {value: identifier.name},
+				fix: fixer => fixer.replaceText(identifier, 'globalThis'),
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `globalThis` over `window`, `self`, and `global`.',
+			recommended: true,
+		},
+		fixable: 'code',
+		hasSuggestions: false,
+		messages,
+	},
+};

package/rules/prefer-includes.js

@@ -1,7 +1,7 @@
 'use strict';
 const isMethodNamed = require('./utils/is-method-named.js');
 const simpleArraySearchRule = require('./shared/simple-array-search-rule.js');
-const {isLiteral} = require('./ast/index.js');
+const {isLiteral, isNegativeOne} = require('./ast/index.js');
 
 const MESSAGE_ID = 'prefer-includes';
 const messages = {
@@ -10,7 +10,6 @@ const messages = {
 // Ignore `{_,lodash,underscore}.{indexOf,lastIndexOf}`
 const ignoredVariables = new Set(['_', 'lodash', 'underscore']);
 const isIgnoredTarget = node => node.type === 'Identifier' && ignoredVariables.has(node.name);
-const isNegativeOne = node => node.type === 'UnaryExpression' && node.operator === '-' && node.argument && node.argument.type === 'Literal' && node.argument.value === 1;
 const isLiteralZero = node => isLiteral(node, 0);
 const isNegativeResult = node => ['===', '==', '<'].includes(node.operator);
 

package/rules/prefer-math-min-max.js

@@ -0,0 +1,80 @@
+'use strict';
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+
+const MESSAGE_ID = 'prefer-math-min-max';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `Math.{{method}}()` to simplify ternary expressions.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	/** @param {import('estree').ConditionalExpression} conditionalExpression */
+	ConditionalExpression(conditionalExpression) {
+		const {test, consequent, alternate} = conditionalExpression;
+
+		if (test.type !== 'BinaryExpression') {
+			return;
+		}
+
+		const {operator, left, right} = test;
+		const [leftText, rightText, alternateText, consequentText] = [left, right, alternate, consequent].map(node => context.sourceCode.getText(node));
+
+		const isGreaterOrEqual = operator === '>' || operator === '>=';
+		const isLessOrEqual = operator === '<' || operator === '<=';
+
+		let method;
+
+		// Prefer `Math.min()`
+		if (
+			// `height > 50 ? 50 : height`
+			(isGreaterOrEqual && leftText === alternateText && rightText === consequentText)
+			// `height < 50 ? height : 50`
+			|| (isLessOrEqual && leftText === consequentText && rightText === alternateText)
+		) {
+			method = 'min';
+		} else if (
+			// `height > 50 ? height : 50`
+			(isGreaterOrEqual && leftText === consequentText && rightText === alternateText)
+			// `height < 50 ? 50 : height`
+			|| (isLessOrEqual && leftText === alternateText && rightText === consequentText)
+		) {
+			method = 'max';
+		}
+
+		if (!method) {
+			return;
+		}
+
+		return {
+			node: conditionalExpression,
+			messageId: MESSAGE_ID,
+			data: {method},
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			* fix(fixer) {
+				const {sourceCode} = context;
+
+				yield * fixSpaceAroundKeyword(fixer, conditionalExpression, sourceCode);
+
+				const argumentsText = [left, right]
+					.map(node => node.type === 'SequenceExpression' ? `(${sourceCode.getText(node)})` : sourceCode.getText(node))
+					.join(', ');
+
+				yield fixer.replaceText(conditionalExpression, `Math.${method}(${argumentsText})`);
+			},
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Prefer `Math.min()` and `Math.max()` over ternaries for simple comparisons.',
+			recommended: true,
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-query-selector.js

@@ -11,10 +11,12 @@ const disallowedIdentifierNames = new Map([
 	['getElementById', 'querySelector'],
 	['getElementsByClassName', 'querySelectorAll'],
 	['getElementsByTagName', 'querySelectorAll'],
+	['getElementsByName', 'querySelectorAll'],
 ]);
 
 const getReplacementForId = value => `#${value}`;
 const getReplacementForClass = value => value.match(/\S+/g).map(className => `.${className}`).join('');
+const getReplacementForName = (value, originQuote) => `[name=${wrapQuoted(value, originQuote)}]`;
 
 const getQuotedReplacement = (node, value) => {
 	const leftQuote = node.raw.charAt(0);
@@ -22,6 +24,24 @@ const getQuotedReplacement = (node, value) => {
 	return `${leftQuote}${value}${rightQuote}`;
 };
 
+const wrapQuoted = (value, originalQuote) => {
+	switch (originalQuote) {
+		case '\'': {
+			return `"${value}"`;
+		}
+
+		case '"': {
+			return `'${value}'`;
+		}
+
+		case '`': {
+			return `'${value}'`;
+		}
+
+		// No default
+	}
+};
+
 function * getLiteralFix(fixer, node, identifierName) {
 	let replacement = node.raw;
 	if (identifierName === 'getElementById') {
@@ -32,6 +52,11 @@ function * getLiteralFix(fixer, node, identifierName) {
 		replacement = getQuotedReplacement(node, getReplacementForClass(node.value));
 	}
 
+	if (identifierName === 'getElementsByName') {
+		const quoted = node.raw.charAt(0);
+		replacement = getQuotedReplacement(node, getReplacementForName(node.value, quoted));
+	}
+
 	yield fixer.replaceText(node, replacement);
 }
 
@@ -53,6 +78,14 @@ function * getTemplateLiteralFix(fixer, node, identifierName) {
 				getReplacementForClass(templateElement.value.cooked),
 			);
 		}
+
+		if (identifierName === 'getElementsByName') {
+			const quoted = node.raw ? node.raw.charAt(0) : '"';
+			yield fixer.replaceText(
+				templateElement,
+				getReplacementForName(templateElement.value.cooked, quoted),
+			);
+		}
 	}
 }
 
@@ -91,7 +124,7 @@ const create = () => ({
 	CallExpression(node) {
 		if (
 			!isMethodCall(node, {
-				methods: ['getElementById', 'getElementsByClassName', 'getElementsByTagName'],
+				methods: ['getElementById', 'getElementsByClassName', 'getElementsByTagName', 'getElementsByName'],
 				argumentsLength: 1,
 				optionalCall: false,
 				optionalMember: false,
@@ -127,7 +160,7 @@ module.exports = {
 	meta: {
 		type: 'suggestion',
 		docs: {
-			description: 'Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()`.',
+			description: 'Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()` and `.getElementsByName()`.',
 			recommended: true,
 		},
 		fixable: 'code',

package/rules/prefer-string-slice.js

@@ -1,7 +1,6 @@
 'use strict';
 const {getStaticValue} = require('@eslint-community/eslint-utils');
 const {getParenthesizedText, getParenthesizedRange} = require('./utils/parentheses.js');
-const isNumber = require('./utils/is-number.js');
 const {replaceArgument} = require('./fix/index.js');
 const {isNumberLiteral, isMethodCall} = require('./ast/index.js');
 
@@ -64,13 +63,6 @@ function * fixSubstrArguments({node, fixer, context, abort}) {
 		return;
 	}
 
-	if (argumentNodes.every(node => isNumber(node, scope))) {
-		const firstArgumentText = getParenthesizedText(firstArgument, sourceCode);
-
-		yield fixer.insertTextBeforeRange(secondArgumentRange, `${firstArgumentText} + `);
-		return;
-	}
-
 	return abort();
 }
 

package/rules/utils/resolve-variable-name.js

@@ -4,8 +4,8 @@
 Finds a variable named `name` in the scope `scope` (or it's parents).
 
 @param {string} name - The variable name to be resolve.
-@param {Scope} scope - The scope to look for the variable in.
-@returns {Variable?} - The found variable, if any.
+@param {import('eslint').Scope.Scope} scope - The scope to look for the variable in.
+@returns {import('eslint').Scope.Variable | void} - The found variable, if any.
 */
 module.exports = function resolveVariableName(name, scope) {
 	while (scope) {