eslint-plugin-unicorn 53.0.0 → 54.0.0

package/index.js

@@ -47,9 +47,12 @@ const allRules = Object.fromEntries(
 	]),
 );
 
-const createConfig = (rules, isLegacyConfig = false) => ({
-	...(isLegacyConfig ? legacyConfigBase : flatConfigBase),
-	plugins: isLegacyConfig ? ['unicorn'] : {unicorn},
+const createConfig = (rules, flatConfigName = false) => ({
+	...(
+		flatConfigName
+			? {...flatConfigBase, name: flatConfigName, plugins: {unicorn}}
+			: {...legacyConfigBase, plugins: ['unicorn']}
+	),
 	rules: {...externalRules, ...rules},
 });
 
@@ -65,10 +68,10 @@ const unicorn = {
 };
 
 const configs = {
-	recommended: createConfig(recommendedRules, /* isLegacyConfig */ true),
-	all: createConfig(allRules, /* isLegacyConfig */ true),
-	'flat/recommended': createConfig(recommendedRules),
-	'flat/all': createConfig(allRules),
+	recommended: createConfig(recommendedRules),
+	all: createConfig(allRules),
+	'flat/recommended': createConfig(recommendedRules, 'unicorn/flat/recommended'),
+	'flat/all': createConfig(allRules, 'unicorn/flat/all'),
 };
 
 module.exports = {...unicorn, configs};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "53.0.0",
+	"version": "54.0.0",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -29,7 +29,7 @@
 		"lint:markdown": "markdownlint \"**/*.md\"",
 		"lint:package-json": "npmPkgJsonLint .",
 		"run-rules-on-codebase": "node ./test/run-rules-on-codebase/lint.mjs",
-		"smoke": "eslint-remote-tester --config ./test/smoke/eslint-remote-tester.config.js",
+		"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"
 	},
@@ -71,7 +71,7 @@
 		"@babel/core": "^7.24.5",
 		"@babel/eslint-parser": "^7.24.5",
 		"@lubien/fixture-beta-package": "^1.0.0-beta.1",
-		"@typescript-eslint/parser": "^7.8.0",
+		"@typescript-eslint/parser": "^8.0.0-alpha.12",
 		"ava": "^6.1.3",
 		"c8": "^9.1.0",
 		"chalk": "^5.3.0",
@@ -81,8 +81,8 @@
 		"eslint-doc-generator": "1.7.0",
 		"eslint-plugin-eslint-plugin": "^6.1.0",
 		"eslint-plugin-internal-rules": "file:./scripts/internal-rules/",
-		"eslint-remote-tester": "^3.0.1",
-		"eslint-remote-tester-repositories": "^1.0.1",
+		"eslint-remote-tester": "^4.0.0",
+		"eslint-remote-tester-repositories": "^2.0.0",
 		"espree": "^10.0.1",
 		"execa": "^8.0.1",
 		"listr": "^0.14.3",

package/readme.md

@@ -145,6 +145,7 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | [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.                                                                                                                                                                                      | ✅  | 🔧 |    |
+| [no-negation-in-equality-check](docs/rules/no-negation-in-equality-check.md)                     | Disallow negated expression in equality check.                                                                                                                                                                    | ✅  |    | 💡 |
 | [no-nested-ternary](docs/rules/no-nested-ternary.md)                                             | Disallow nested ternary expressions.                                                                                                                                                                              | ✅  | 🔧 |    |
 | [no-new-array](docs/rules/no-new-array.md)                                                       | Disallow `new Array()`.                                                                                                                                                                                           | ✅  | 🔧 | 💡 |
 | [no-new-buffer](docs/rules/no-new-buffer.md)                                                     | Enforce the use of `Buffer.from()` and `Buffer.alloc()` instead of the deprecated `new Buffer()`.                                                                                                                 | ✅  | 🔧 | 💡 |
@@ -175,7 +176,7 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | [prefer-array-flat](docs/rules/prefer-array-flat.md)                                             | Prefer `Array#flat()` over legacy techniques to flatten arrays.                                                                                                                                                   | ✅  | 🔧 |    |
 | [prefer-array-flat-map](docs/rules/prefer-array-flat-map.md)                                     | Prefer `.flatMap(…)` over `.map(…).flat()`.                                                                                                                                                                       | ✅  | 🔧 |    |
 | [prefer-array-index-of](docs/rules/prefer-array-index-of.md)                                     | Prefer `Array#{indexOf,lastIndexOf}()` over `Array#{findIndex,findLastIndex}()` when looking for the index of an item.                                                                                            | ✅  | 🔧 | 💡 |
-| [prefer-array-some](docs/rules/prefer-array-some.md)                                             | Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast}(…)`.                                                                                                                                       | ✅  | 🔧 | 💡 |
+| [prefer-array-some](docs/rules/prefer-array-some.md)                                             | Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast,findIndex,findLastIndex}(…)`.                                                                                                               | ✅  | 🔧 | 💡 |
 | [prefer-at](docs/rules/prefer-at.md)                                                             | Prefer `.at()` method for index access and `String#charAt()`.                                                                                                                                                     | ✅  | 🔧 | 💡 |
 | [prefer-blob-reading-methods](docs/rules/prefer-blob-reading-methods.md)                         | Prefer `Blob#arrayBuffer()` over `FileReader#readAsArrayBuffer(…)` and `Blob#text()` over `FileReader#readAsText(…)`.                                                                                             | ✅  |    |    |
 | [prefer-code-point](docs/rules/prefer-code-point.md)                                             | Prefer `String#codePointAt(…)` over `String#charCodeAt(…)` and `String.fromCodePoint(…)` over `String.fromCharCode(…)`.                                                                                           | ✅  |    | 💡 |
@@ -187,7 +188,7 @@ 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-includes](docs/rules/prefer-includes.md)                                                 | Prefer `.includes()` over `.indexOf()` and `Array#some()` when checking for existence or non-existence.                                                                                                           | ✅  | 🔧 | 💡 |
+| [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.                                                                                                                                                                   | ✅  |    | 💡 |

package/rules/ast/is-reference-identifier.js

@@ -120,11 +120,18 @@ function isNotReference(node) {
 			return parent.parameters.includes(node);
 		}
 
+		// `@typescript-eslint/parse` v7
 		// `type Foo = { [Identifier in keyof string]: number; };`
 		case 'TSTypeParameter': {
 			return parent.name === node;
 		}
 
+		// `@typescript-eslint/parse` v8
+		// `type Foo = { [Identifier in keyof string]: number; };`
+		case 'TSMappedType': {
+			return parent.key === node;
+		}
+
 		// `type Identifier = Foo`
 		case 'TSTypeAliasDeclaration': {
 			return parent.id === node;

package/rules/fix/switch-call-expression-to-new-expression.js

@@ -1,8 +1,10 @@
 'use strict';
 const {isParenthesized} = require('../utils/parentheses.js');
 const shouldAddParenthesesToNewExpressionCallee = require('../utils/should-add-parentheses-to-new-expression-callee.js');
+const fixSpaceAroundKeyword = require('./fix-space-around-keywords.js');
 
 function * switchCallExpressionToNewExpression(node, sourceCode, fixer) {
+	yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
 	yield fixer.insertTextBefore(node, 'new ');
 
 	const {callee} = node;

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

@@ -0,0 +1,104 @@
+'use strict';
+const {
+	fixSpaceAroundKeyword,
+	addParenthesizesToReturnOrThrowExpression,
+} = require('./fix/index.js');
+const {
+	needsSemicolon,
+	isParenthesized,
+	isOnSameLine,
+} = require('./utils/index.js');
+
+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_SUGGESTION]: 'Switch to \'{{operator}}\' check.',
+};
+
+const EQUALITY_OPERATORS = new Set([
+	'===',
+	'!==',
+	'==',
+	'!=',
+]);
+
+const isEqualityCheck = node => node.type === 'BinaryExpression' && EQUALITY_OPERATORS.has(node.operator);
+const isNegatedExpression = node => node.type === 'UnaryExpression' && node.prefix && node.operator === '!';
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	BinaryExpression(binaryExpression) {
+		const {operator, left} = binaryExpression;
+
+		if (
+			!isEqualityCheck(binaryExpression)
+			|| !isNegatedExpression(left)
+		) {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const bangToken = sourceCode.getFirstToken(left);
+		const negatedOperator = `${operator.startsWith('!') ? '=' : '!'}${operator.slice(1)}`;
+
+		return {
+			node: bangToken,
+			messageId: MESSAGE_ID_ERROR,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			suggest: [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					data: {
+						operator: negatedOperator,
+					},
+					/** @param {import('eslint').Rule.RuleFixer} fixer */
+					* fix(fixer) {
+						yield * fixSpaceAroundKeyword(fixer, binaryExpression, sourceCode);
+
+						const tokenAfterBang = sourceCode.getTokenAfter(bangToken);
+
+						const {parent} = binaryExpression;
+						if (
+							(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
+							&& !isParenthesized(binaryExpression, sourceCode)
+						) {
+							const returnToken = sourceCode.getFirstToken(parent);
+							if (!isOnSameLine(returnToken, tokenAfterBang)) {
+								yield * addParenthesizesToReturnOrThrowExpression(fixer, parent, sourceCode);
+							}
+						}
+
+						yield fixer.remove(bangToken);
+
+						const previousToken = sourceCode.getTokenBefore(bangToken);
+						if (needsSemicolon(previousToken, sourceCode, tokenAfterBang.value)) {
+							yield fixer.insertTextAfter(bangToken, ';');
+						}
+
+						const operatorToken = sourceCode.getTokenAfter(
+							left,
+							token => token.type === 'Punctuator' && token.value === operator,
+						);
+						yield fixer.replaceText(operatorToken, negatedOperator);
+					},
+				},
+			],
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow negated expression in equality check.',
+			recommended: true,
+		},
+
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/prefer-array-find.js

@@ -180,7 +180,7 @@ const create = context => {
 	const {
 		checkFromLast,
 	} = {
-		checkFromLast: false,
+		checkFromLast: true,
 		...context.options[0],
 	};
 
@@ -428,8 +428,8 @@ const schema = [
 		properties: {
 			checkFromLast: {
 				type: 'boolean',
-				// TODO: Change default value to `true`, or remove the option when targeting Node.js 18.
-				default: false,
+				// TODO: Remove the option at some point.
+				default: true,
 			},
 		},
 	},

package/rules/prefer-array-flat.js

@@ -46,7 +46,6 @@ const arrayFlatMap = {
 	},
 	getArrayNode: node => node.callee.object,
 	description: 'Array#flatMap()',
-	recommended: true,
 };
 
 // `array.reduce((a, b) => a.concat(b), [])`
@@ -100,7 +99,6 @@ const arrayReduce = {
 	},
 	getArrayNode: node => node.callee.object,
 	description: 'Array#reduce()',
-	recommended: true,
 };
 
 // `[].concat(maybeArray)`
@@ -121,7 +119,6 @@ const emptyArrayConcat = {
 		return argumentNode.type === 'SpreadElement' ? argumentNode.argument : argumentNode;
 	},
 	description: '[].concat()',
-	recommended: true,
 	shouldSwitchToArray: node => node.arguments[0].type !== 'SpreadElement',
 };
 
@@ -157,7 +154,6 @@ const arrayPrototypeConcat = {
 		return argumentNode.type === 'SpreadElement' ? argumentNode.argument : argumentNode;
 	},
 	description: 'Array.prototype.concat()',
-	recommended: true,
 	shouldSwitchToArray: node => node.arguments[1].type !== 'SpreadElement' && node.callee.property.name === 'call',
 };
 

package/rules/prefer-array-some.js

@@ -40,10 +40,14 @@ const isCheckingUndefined = node =>
 			&& isLiteral(node.parent.right, null)
 		)
 	);
+const isNegativeOne = node => node.type === 'UnaryExpression' && node.operator === '-' && node.argument && node.argument.type === 'Literal' && node.argument.value === 1;
+const isLiteralZero = node => isLiteral(node, 0);
 
 /** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	CallExpression(callExpression) {
+const create = context => {
+	// `.find(…)`
+	// `.findLast(…)`
+	context.on('CallExpression', callExpression => {
 		if (!isMethodCall(callExpression, {
 			methods: ['find', 'findLast'],
 			minimumArguments: 1,
@@ -86,8 +90,61 @@ const create = context => ({
 				},
 			],
 		};
-	},
-	BinaryExpression(binaryExpression) {
+	});
+
+	// These operators also used in `prefer-includes`, try to reuse the code in future
+	// `.{findIndex,findLastIndex}(…) !== -1`
+	// `.{findIndex,findLastIndex}(…) != -1`
+	// `.{findIndex,findLastIndex}(…) > -1`
+	// `.{findIndex,findLastIndex}(…) === -1`
+	// `.{findIndex,findLastIndex}(…) == -1`
+	// `.{findIndex,findLastIndex}(…) >= 0`
+	// `.{findIndex,findLastIndex}(…) < 0`
+	context.on('BinaryExpression', binaryExpression => {
+		const {left, right, operator} = binaryExpression;
+
+		if (!(
+			isMethodCall(left, {
+				methods: ['findIndex', 'findLastIndex'],
+				argumentsLength: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& (
+				(['!==', '!=', '>', '===', '=='].includes(operator) && isNegativeOne(right))
+				|| (['>=', '<'].includes(operator) && isLiteralZero(right))
+			)
+		)) {
+			return;
+		}
+
+		const methodNode = left.callee.property;
+		return {
+			node: methodNode,
+			messageId: ERROR_ID_ARRAY_SOME,
+			data: {method: methodNode.name},
+			* fix(fixer) {
+				if (['===', '==', '<'].includes(operator)) {
+					yield fixer.insertTextBefore(binaryExpression, '!');
+				}
+
+				yield fixer.replaceText(methodNode, 'some');
+
+				const operatorToken = context.sourceCode.getTokenAfter(
+					left,
+					token => token.type === 'Punctuator' && token.value === operator,
+				);
+				const [start] = operatorToken.range;
+				const [, end] = binaryExpression.range;
+
+				yield fixer.removeRange([start, end]);
+			},
+		};
+	});
+
+	// `.filter(…).length > 0`
+	// `.filter(…).length !== 0`
+	context.on('BinaryExpression', binaryExpression => {
 		if (!(
 			// We assume the user already follows `unicorn/explicit-length-check`. These are allowed in that rule.
 			(binaryExpression.operator === '>' || binaryExpression.operator === '!==')
@@ -139,8 +196,8 @@ const create = context => ({
 				// The `BinaryExpression` always ends with a number or `)`, no need check for ASI
 			},
 		};
-	},
-});
+	});
+};
 
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
@@ -148,7 +205,7 @@ module.exports = {
 	meta: {
 		type: 'suggestion',
 		docs: {
-			description: 'Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast}(…)`.',
+			description: 'Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast,findIndex,findLastIndex}(…)`.',
 			recommended: true,
 		},
 		fixable: 'code',

package/rules/prefer-includes.js

@@ -5,9 +5,9 @@ const {isLiteral} = require('./ast/index.js');
 
 const MESSAGE_ID = 'prefer-includes';
 const messages = {
-	[MESSAGE_ID]: 'Use `.includes()`, rather than `.indexOf()`, when checking for existence.',
+	[MESSAGE_ID]: 'Use `.includes()`, rather than `.{{method}}()`, when checking for existence.',
 };
-// Ignore {_,lodash,underscore}.indexOf
+// 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;
@@ -30,6 +30,9 @@ const getProblem = (context, node, target, argumentsNodes) => {
 	return {
 		node: memberExpressionNode.property,
 		messageId: MESSAGE_ID,
+		data: {
+			method: node.left.callee.property.name,
+		},
 		fix(fixer) {
 			const replacement = `${isNegativeResult(node) ? '!' : ''}${targetSource}.includes(${argumentsSource.join(', ')})`;
 			return fixer.replaceText(node, replacement);
@@ -49,7 +52,7 @@ const create = context => {
 	context.on('BinaryExpression', node => {
 		const {left, right, operator} = node;
 
-		if (!isMethodNamed(left, 'indexOf')) {
+		if (!isMethodNamed(left, 'indexOf') && !isMethodNamed(left, 'lastIndexOf')) {
 			return;
 		}
 
@@ -86,7 +89,7 @@ module.exports = {
 	meta: {
 		type: 'suggestion',
 		docs: {
-			description: 'Prefer `.includes()` over `.indexOf()` and `Array#some()` when checking for existence or non-existence.',
+			description: 'Prefer `.includes()` over `.indexOf()`, `.lastIndexOf()`, and `Array#some()` when checking for existence or non-existence.',
 			recommended: true,
 		},
 		fixable: 'code',

package/rules/prefer-modern-math-apis.js

@@ -154,7 +154,6 @@ const create = context => {
 				data: {
 					replacement: `Math.${replacementMethod}(…)`,
 					description: 'Math.sqrt(…)',
-					recommended: true,
 				},
 				* fix(fixer) {
 					const {sourceCode} = context;

package/rules/prefer-string-raw.js

@@ -47,6 +47,7 @@ const create = context => {
 			)
 			|| (node.parent.type === 'Property' && !node.parent.computed && node.parent.key === node)
 			|| (node.parent.type === 'JSXAttribute' && node.parent.value === node)
+			|| (node.parent.type === 'TSEnumMember' && (node.parent.initializer === node || node.parent.id === node))
 		) {
 			return;
 		}

package/rules/prefer-structured-clone.js

@@ -61,7 +61,6 @@ const create = context => {
 			messageId: MESSAGE_ID_ERROR,
 			data: {
 				description: 'JSON.parse(JSON.stringify(…))',
-				recommended: true,
 			},
 			suggest: [
 				{