eslint-plugin-unicorn 54.0.0 → 56.0.0

package/configs/flat-config-base.js

@@ -1,10 +1,8 @@
 'use strict';
-const eslintrc = require('@eslint/eslintrc');
-
-const {globals} = eslintrc.Legacy.environments.get('es2024');
+const globals = require('globals');
 
 module.exports = {
 	languageOptions: {
-		globals,
+		globals: globals.builtin,
 	},
 };

package/index.d.ts

@@ -0,0 +1,12 @@
+import type {ESLint, Linter} from 'eslint';
+
+declare const eslintPluginUnicorn: ESLint.Plugin & {
+	configs: {
+		recommended: Linter.Config;
+		all: Linter.Config;
+		'flat/all': Linter.FlatConfig;
+		'flat/recommended': Linter.FlatConfig;
+	};
+};
+
+export = eslintPluginUnicorn;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "54.0.0",
+	"version": "56.0.0",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -11,6 +11,7 @@
 		"url": "https://sindresorhus.com"
 	},
 	"main": "index.js",
+	"types": "index.d.ts",
 	"sideEffects": false,
 	"engines": {
 		"node": ">=18.18"
@@ -28,13 +29,14 @@
 		"lint:js": "xo",
 		"lint:markdown": "markdownlint \"**/*.md\"",
 		"lint:package-json": "npmPkgJsonLint .",
-		"run-rules-on-codebase": "node ./test/run-rules-on-codebase/lint.mjs",
+		"run-rules-on-codebase": "eslint --config=./eslint.dogfooding.config.mjs",
 		"smoke": "eslint-remote-tester --config ./test/smoke/eslint-remote-tester.config.mjs",
 		"test": "npm-run-all --continue-on-error lint test:*",
 		"test:js": "c8 ava"
 	},
 	"files": [
 		"index.js",
+		"index.d.ts",
 		"rules",
 		"configs"
 	],
@@ -49,13 +51,13 @@
 		"xo"
 	],
 	"dependencies": {
-		"@babel/helper-validator-identifier": "^7.24.5",
+		"@babel/helper-validator-identifier": "^7.24.7",
 		"@eslint-community/eslint-utils": "^4.4.0",
-		"@eslint/eslintrc": "^3.0.2",
 		"ci-info": "^4.0.0",
 		"clean-regexp": "^1.0.0",
-		"core-js-compat": "^3.37.0",
-		"esquery": "^1.5.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",
@@ -63,40 +65,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.2.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"

package/readme.md

@@ -27,12 +27,12 @@ If you don't use the preset, ensure you use the same `languageOptions` config as
 
 ```js
 import eslintPluginUnicorn from 'eslint-plugin-unicorn';
-import * as eslintrc from '@eslint/eslintrc';
+import globals from 'globals';
 
 export default [
 	{
 		languageOptions: {
-			globals: eslintrc.Legacy.environments.get('es2024'),
+			globals: globals.builtin,
 		},
 		plugins: {
 			unicorn: eslintPluginUnicorn,
@@ -51,12 +51,12 @@ export default [
 ```js
 'use strict';
 const eslintPluginUnicorn = require('eslint-plugin-unicorn');
-const eslintrc = require('@eslint/eslintrc');
+const globals = require('globals');
 
 module.exports = [
 	{
 		languageOptions: {
-			globals: eslintrc.Legacy.environments.get('es2024'),
+			globals: globals.builtin,
 		},
 		plugins: {
 			unicorn: eslintPluginUnicorn,
@@ -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.                                                                                                                                                                                 | ✅  | 🔧 |    |
@@ -142,6 +143,7 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | [no-invalid-fetch-options](docs/rules/no-invalid-fetch-options.md)                               | Disallow invalid options in `fetch()` and `new Request()`.                                                                                                                                                        | ✅  |    |    |
 | [no-invalid-remove-event-listener](docs/rules/no-invalid-remove-event-listener.md)               | Prevent calling `EventTarget#removeEventListener()` with the result of an expression.                                                                                                                             | ✅  |    |    |
 | [no-keyword-prefix](docs/rules/no-keyword-prefix.md)                                             | Disallow identifiers starting with `new` or `class`.                                                                                                                                                              |    |    |    |
+| [no-length-as-slice-end](docs/rules/no-length-as-slice-end.md)                                   | Disallow using `.length` as the `end` argument of `{Array,String,TypedArray}#slice()`.                                                                                                                            | ✅  | 🔧 |    |
 | [no-lonely-if](docs/rules/no-lonely-if.md)                                                       | Disallow `if` statements as the only statement in `if` blocks without `else`.                                                                                                                                     | ✅  | 🔧 |    |
 | [no-magic-array-flat-depth](docs/rules/no-magic-array-flat-depth.md)                             | Disallow a magic number as the `depth` argument in `Array#flat(…).`                                                                                                                                               | ✅  |    |    |
 | [no-negated-condition](docs/rules/no-negated-condition.md)                                       | Disallow negated conditions.                                                                                                                                                                                      | ✅  | 🔧 |    |
@@ -188,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.                                                                                                                                                                   | ✅  | 🔧 |    |
@@ -203,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.                                                                                                                          | ✅  | 🔧 | 💡 |

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/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-length-as-slice-end.js

@@ -0,0 +1,53 @@
+'use strict';
+const {isMethodCall, isMemberExpression} = require('./ast/index.js');
+const {removeArgument} = require('./fix/index.js');
+const {isSameReference} = require('./utils/index.js');
+
+const MESSAGE_ID = 'no-length-as-slice-end';
+const messages = {
+	[MESSAGE_ID]: 'Passing `….length` as the `end` argument is unnecessary.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('CallExpression', callExpression => {
+		if (!isMethodCall(callExpression, {
+			method: 'slice',
+			argumentsLength: 2,
+			optionalCall: false,
+		})) {
+			return;
+		}
+
+		const secondArgument = callExpression.arguments[1];
+		const node = secondArgument.type === 'ChainExpression' ? secondArgument.expression : secondArgument;
+
+		if (
+			!isMemberExpression(node, {property: 'length', computed: false})
+			|| !isSameReference(callExpression.callee.object, node.object)
+		) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			fix: fixer => removeArgument(fixer, secondArgument, context.sourceCode),
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow using `.length` as the `end` argument of `{Array,String,TypedArray}#slice()`.',
+			recommended: true,
+		},
+		fixable: 'code',
+		messages,
+	},
+};

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

@@ -31,10 +31,11 @@ const create = context => ({
 	BinaryExpression(binaryExpression) {
 		const {operator, left} = binaryExpression;
 
-		if (
-			!isEqualityCheck(binaryExpression)
-			|| !isNegatedExpression(left)
-		) {
+		if (!(
+			isEqualityCheck(binaryExpression)
+			&& isNegatedExpression(left)
+			&& !isNegatedExpression(left.argument)
+		)) {
 			return;
 		}
 

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-single-promise-in-promise-methods.js

@@ -2,7 +2,10 @@
 const {
 	isCommaToken,
 } = require('@eslint-community/eslint-utils');
-const {isMethodCall} = require('./ast/index.js');
+const {
+	isMethodCall,
+	isExpressionStatement,
+} = require('./ast/index.js');
 const {
 	getParenthesizedText,
 	isParenthesized,
@@ -77,8 +80,8 @@ const unwrapNonAwaitedCallExpression = (callExpression, sourceCode) => fixer =>
 const switchToPromiseResolve = (callExpression, sourceCode) => function * (fixer) {
 	/*
 	```
-	Promise.all([promise,])
-	//      ^^^ methodNameNode
+	Promise.race([promise,])
+	//      ^^^^ methodNameNode
 	```
 	*/
 	const methodNameNode = callExpression.callee.property;
@@ -87,16 +90,16 @@ const switchToPromiseResolve = (callExpression, sourceCode) => function * (fixer
 	const [arrayExpression] = callExpression.arguments;
 	/*
 	```
-	Promise.all([promise,])
-	//          ^ openingBracketToken
+	Promise.race([promise,])
+	//           ^ openingBracketToken
 	```
 	*/
 	const openingBracketToken = sourceCode.getFirstToken(arrayExpression);
 	/*
 	```
-	Promise.all([promise,])
-	//                  ^ penultimateToken
-	//                   ^ closingBracketToken
+	Promise.race([promise,])
+	//                   ^ penultimateToken
+	//                    ^ closingBracketToken
 	```
 	*/
 	const [
@@ -119,11 +122,13 @@ const create = context => ({
 			return;
 		}
 
+		const methodName = callExpression.callee.property.name;
+
 		const problem = {
 			node: callExpression.arguments[0],
 			messageId: MESSAGE_ID_ERROR,
 			data: {
-				method: callExpression.callee.property.name,
+				method: methodName,
 			},
 		};
 
@@ -132,11 +137,19 @@ const create = context => ({
 		if (
 			callExpression.parent.type === 'AwaitExpression'
 			&& callExpression.parent.argument === callExpression
+			&& (
+				methodName !== 'all'
+				|| isExpressionStatement(callExpression.parent.parent)
+			)
 		) {
 			problem.fix = unwrapAwaitedCallExpression(callExpression, sourceCode);
 			return problem;
 		}
 
+		if (methodName === 'all') {
+			return problem;
+		}
+
 		problem.suggest = [
 			{
 				messageId: MESSAGE_ID_SUGGESTION_UNWRAP,

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-node-protocol.js

@@ -32,8 +32,8 @@ const create = () => ({
 		if (
 			typeof value !== 'string'
 			|| value.startsWith('node:')
+			|| /^bun(?::|$)/.test(value)
 			|| !isBuiltinModule(value)
-			|| !isBuiltinModule(`node:${value}`)
 		) {
 			return;
 		}

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) {