eslint-plugin-unicorn 69.0.0 → 70.0.0

package/rules/no-negated-comparison.js

@@ -1,13 +1,21 @@
 import {
 	removeParentheses,
 	fixSpaceAroundKeyword,
-	addParenthesizesToReturnOrThrowExpression,
+	addParenthesesToReturnOrThrowExpression,
 } from './fix/index.js';
 import {
 	isParenthesized,
 	isOnSameLine,
 	needsSemicolon,
 } from './utils/index.js';
+import {
+	getBinaryExpressionWithReplacedOperatorText,
+	getPunctuatorBinaryExpressionOperatorToken,
+	hasLowerLogicalOperatorPrecedence,
+	negatedComparisonOperators,
+	negatedEqualityOperators,
+	negatedLogicalOperators,
+} from './utils/comparison.js';
 
 const MESSAGE_ID_ERROR = 'no-negated-comparison/error';
 const MESSAGE_ID_LOGICAL_ERROR = 'no-negated-comparison/logical-error';
@@ -20,29 +28,6 @@ const messages = {
 	[MESSAGE_ID_LOGICAL_SUGGESTION]: 'Switch to opposite comparisons.',
 };
 
-const operatorReplacements = new Map([
-	['===', '!=='],
-	['!==', '==='],
-	['==', '!='],
-	['!=', '=='],
-	['>', '<='],
-	['>=', '<'],
-	['<', '>='],
-	['<=', '>'],
-]);
-
-const safelyFixableOperators = new Set([
-	'===',
-	'!==',
-	'==',
-	'!=',
-]);
-
-const logicalOperatorReplacements = new Map([
-	['&&', '||'],
-	['||', '&&'],
-]);
-
 const defaultOptions = {
 	checkLogicalExpressions: false,
 };
@@ -72,20 +57,20 @@ const isNegation = node =>
 
 const isComparison = node =>
 	node.type === 'BinaryExpression'
-	&& operatorReplacements.has(node.operator);
+	&& negatedComparisonOperators.has(node.operator);
 
 const isLogicalExpressionWithOnlyComparisons = node =>
 	isComparison(node)
 	|| (
 		node.type === 'LogicalExpression'
-		&& logicalOperatorReplacements.has(node.operator)
+		&& negatedLogicalOperators.has(node.operator)
 		&& isLogicalExpressionWithOnlyComparisons(node.left)
 		&& isLogicalExpressionWithOnlyComparisons(node.right)
 	);
 
 const isSafelyFixableLogicalExpression = node =>
 	isComparison(node)
-		? safelyFixableOperators.has(node.operator)
+		? negatedEqualityOperators.has(node.operator)
 		: isSafelyFixableLogicalExpression(node.left) && isSafelyFixableLogicalExpression(node.right);
 
 const parentNeedsGroupedComparison = parent => [
@@ -111,10 +96,7 @@ function * fix({
 	const bangToken = sourceCode.getFirstToken(unaryExpression);
 	const tokenAfterBang = sourceCode.getTokenAfter(bangToken);
 	const tokenAfterBangIncludingComments = sourceCode.getTokenAfter(bangToken, {includeComments: true});
-	const operatorToken = sourceCode.getTokenAfter(
-		comparison.left,
-		token => token.type === 'Punctuator' && token.value === comparison.operator,
-	);
+	const operatorToken = getPunctuatorBinaryExpressionOperatorToken(comparison, context);
 	const {parent} = unaryExpression;
 	const needsReturnOrThrowParentheses = (
 		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
@@ -145,7 +127,7 @@ function * fix({
 	yield fixer.replaceText(operatorToken, replacementOperator);
 
 	if (needsReturnOrThrowParentheses) {
-		yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+		yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 		return;
 	}
 
@@ -156,37 +138,18 @@ function * fix({
 	}
 }
 
-const logicalOperatorPrecedence = {
-	'||': 1,
-	'&&': 2,
-};
-
-const getOperatorToken = (comparison, sourceCode) => sourceCode.getTokenAfter(
-	comparison.left,
-	token => token.type === 'Punctuator' && token.value === comparison.operator,
+const getFixedComparisonText = (comparison, context) => getBinaryExpressionWithReplacedOperatorText(
+	comparison,
+	context,
+	negatedComparisonOperators.get(comparison.operator),
 );
 
-const getFixedComparisonText = (comparison, sourceCode) => {
-	const operatorToken = getOperatorToken(comparison, sourceCode);
-	const [comparisonStart] = sourceCode.getRange(comparison);
-	const [operatorStart, operatorEnd] = sourceCode.getRange(operatorToken);
-	const comparisonText = sourceCode.getText(comparison);
-
-	return [
-		comparisonText.slice(0, operatorStart - comparisonStart),
-		operatorReplacements.get(comparison.operator),
-		comparisonText.slice(operatorEnd - comparisonStart),
-	].join('');
-};
-
 const getFixedLogicalExpressionText = (node, context, parentOperator) => {
-	const {sourceCode} = context;
-
 	if (isComparison(node)) {
-		return getFixedComparisonText(node, sourceCode);
+		return getFixedComparisonText(node, context);
 	}
 
-	const operator = logicalOperatorReplacements.get(node.operator);
+	const operator = negatedLogicalOperators.get(node.operator);
 	const text = [
 		getFixedLogicalExpressionText(node.left, context, operator),
 		operator,
@@ -197,7 +160,7 @@ const getFixedLogicalExpressionText = (node, context, parentOperator) => {
 			operator !== parentOperator
 			&& isParenthesized(node, context)
 		)
-		|| logicalOperatorPrecedence[operator] < logicalOperatorPrecedence[parentOperator]
+		|| hasLowerLogicalOperatorPrecedence(operator, parentOperator)
 	);
 
 	return needsParentheses
@@ -230,7 +193,7 @@ function * fixLogical({
 	yield fixer.replaceText(logicalExpression, getFixedLogicalExpressionText(logicalExpression, context));
 
 	if (needsReturnOrThrowParentheses) {
-		yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+		yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 		return;
 	}
 
@@ -253,7 +216,7 @@ const create = context => {
 
 		if (isComparison(argument)) {
 			const comparison = argument;
-			const replacementOperator = operatorReplacements.get(comparison.operator);
+			const replacementOperator = negatedComparisonOperators.get(comparison.operator);
 			const problem = {
 				node: unaryExpression,
 				messageId: MESSAGE_ID_ERROR,
@@ -267,7 +230,7 @@ const create = context => {
 				replacementOperator,
 			});
 
-			if (safelyFixableOperators.has(comparison.operator)) {
+			if (negatedEqualityOperators.has(comparison.operator)) {
 				problem.fix = fixFunction;
 			} else {
 				problem.suggest = [

package/rules/no-negated-condition.js

@@ -5,7 +5,7 @@ https://github.com/eslint/eslint/blob/5c39425fc55ecc0b97bbd07ac22654c0eb4f789c/l
 import {
 	removeParentheses,
 	fixSpaceAroundKeyword,
-	addParenthesizesToReturnOrThrowExpression,
+	addParenthesesToReturnOrThrowExpression,
 } from './fix/index.js';
 import {
 	getParenthesizedRange,
@@ -118,7 +118,7 @@ const create = context => {
 					&& !isParenthesized(node, context)
 					&& !isParenthesized(test, context)
 				) {
-					yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+					yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 					return;
 				}
 

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

@@ -1,4 +1,4 @@
-import {fixSpaceAroundKeyword, addParenthesizesToReturnOrThrowExpression} from './fix/index.js';
+import {fixSpaceAroundKeyword, addParenthesesToReturnOrThrowExpression} from './fix/index.js';
 import {needsSemicolon, isParenthesized, isOnSameLine} from './utils/index.js';
 
 const MESSAGE_ID_ERROR = 'no-negation-in-equality-check/error';
@@ -58,7 +58,7 @@ const create = context => {
 						) {
 							const returnToken = sourceCode.getFirstToken(parent);
 							if (!isOnSameLine(returnToken, tokenAfterBang, context)) {
-								yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+								yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 							}
 						}
 

package/rules/no-non-function-verb-prefix.js

@@ -1,3 +1,4 @@
+import {isRegExp} from 'node:util/types';
 import {
 	isNullishType,
 	isTypeScriptFile,
@@ -31,8 +32,12 @@ const messages = {
 
 const isUppercaseAscii = character => character >= 'A' && character <= 'Z';
 
-const prepareOptions = ({verbs}) => ({
+const prepareOptions = ({
+	verbs,
+	ignore = [],
+}) => ({
 	verbs: verbs.toSorted((first, second) => second.length - first.length),
+	ignore: ignore.map(pattern => isRegExp(pattern) ? pattern : new RegExp(pattern, 'u')),
 });
 
 function getVerbPrefix(name, verbs) {
@@ -129,6 +134,15 @@ const getIntersectionTypeCallability = (type, checker, program, visitedTypes) =>
 const isInDeclaredModule = (node, sourceCode) =>
 	sourceCode.getAncestors(node).some(ancestor => ancestor.type === 'TSModuleDeclaration' && ancestor.declare);
 
+function isIgnoredName(name, ignore) {
+	return ignore.some(regexp => {
+		regexp.lastIndex = 0;
+		const isIgnored = regexp.test(name);
+		regexp.lastIndex = 0;
+		return isIgnored;
+	});
+}
+
 function getTypeCallability(type, checker, program, visitedTypes = new Set()) {
 	if (isIgnoredType(type)) {
 		return unknown;
@@ -184,6 +198,10 @@ function getProblem(identifier, context, options, typeNode = identifier) {
 		return;
 	}
 
+	if (isIgnoredName(identifier.name, options.ignore)) {
+		return;
+	}
+
 	const {parserServices} = context.sourceCode;
 	let type;
 	try {
@@ -298,6 +316,11 @@ const schema = [
 				uniqueItems: true,
 				description: 'Function-style verb prefixes to check.',
 			},
+			ignore: {
+				type: 'array',
+				uniqueItems: true,
+				description: 'Patterns to ignore.',
+			},
 		},
 	},
 ];
@@ -313,7 +336,7 @@ const config = {
 			requiresTypeChecking: true,
 		},
 		schema,
-		defaultOptions: [{verbs: defaultVerbs}],
+		defaultOptions: [{verbs: defaultVerbs, ignore: []}],
 		messages,
 		languages: [
 			'js/js',

package/rules/no-return-array-push.js

@@ -1,5 +1,5 @@
 import {isMethodCall} from './ast/index.js';
-import {isKnownNonArray, needsSemicolon} from './utils/index.js';
+import {isArray, isKnownNonArray, needsSemicolon} from './utils/index.js';
 
 const MESSAGE_ID_ERROR = 'no-return-array-push/error';
 const MESSAGE_ID_SUGGESTION = 'no-return-array-push/suggestion';
@@ -10,7 +10,10 @@ const messages = {
 
 const ignoredCallees = [
 	'stream.push',
+	'router.push',
 	'this.push',
+	'this.router.push',
+	'this.$router.push',
 	'this.stream.push',
 	'process.stdin.push',
 	'process.stdout.push',
@@ -53,6 +56,10 @@ function isStaticMemberPath(node, path) {
 
 const isIgnoredCallee = callee => ignoredCallees.some(ignoredCallee => isStaticMemberPath(callee, ignoredCallee));
 
+const isIgnoredPushCallee = (callExpression, context) =>
+	isIgnoredCallee(callExpression.callee)
+	&& !isArray(callExpression.callee.object, context);
+
 function getCallExpressionResultNode(callExpression) {
 	let node = callExpression;
 
@@ -133,7 +140,7 @@ const create = context => {
 		const {name: method} = property;
 
 		if (
-			(method === 'push' && isIgnoredCallee(callExpression.callee))
+			(method === 'push' && isIgnoredPushCallee(callExpression, context))
 			|| isReturnValueDiscarded(callExpression)
 			|| isResultMemberAccessed(callExpression)
 			|| isKnownNonArray(callExpression.callee.object, context)

package/rules/no-typeof-undefined.js

@@ -1,6 +1,6 @@
 import {isLiteral} from './ast/index.js';
 import {
-	addParenthesizesToReturnOrThrowExpression,
+	addParenthesesToReturnOrThrowExpression,
 	removeSpacesAfter,
 } from './fix/index.js';
 import {
@@ -74,7 +74,7 @@ const create = context => {
 				&& !isParenthesized(binaryExpression, context)
 				&& !isParenthesized(typeofNode, context)
 			) {
-				yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+				yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 				return;
 			}
 

package/rules/no-unnecessary-array-flat-map.js

@@ -0,0 +1,307 @@
+import {hasSideEffect} from '@eslint-community/eslint-utils';
+import {isMethodCall} from './ast/index.js';
+import {
+	getParenthesizedText,
+	isKnownNonArray,
+	isParenthesized,
+	isSameIdentifier,
+	shouldAddParenthesesToMemberExpressionObject,
+	wouldRemoveComments,
+} from './utils/index.js';
+
+const MESSAGE_ID = 'no-unnecessary-array-flat-map';
+const SUGGESTION_ID_FILTER_MAP = 'no-unnecessary-array-flat-map/filter-map-suggestion';
+
+const messages = {
+	[MESSAGE_ID]: 'Prefer `.{{method}}(…)` over `.flatMap(…)` for this single-item array callback.',
+	[SUGGESTION_ID_FILTER_MAP]: 'Replace `.flatMap(…)` with `.filter(…).map(…)`.',
+};
+
+const arrowBodyNeedsParenthesesTypes = new Set([
+	'ObjectExpression',
+	'SequenceExpression',
+]);
+
+const typescriptExpressionWrapperTypes = new Set([
+	'TSAsExpression',
+	'TSNonNullExpression',
+	'TSSatisfiesExpression',
+	'TSTypeAssertion',
+]);
+
+const hasTypeArguments = node => node.typeArguments || node.typeParameters;
+
+const isFilterCallExpression = node => isMethodCall(node, {
+	method: 'filter',
+	argumentsLength: 1,
+	optionalCall: false,
+	optionalMember: false,
+	computed: false,
+});
+
+const isSimpleSingleParameterArrowCallback = node =>
+	node.type === 'ArrowFunctionExpression'
+	&& !node.async
+	&& !node.returnType
+	&& !node.typeParameters
+	&& node.params.length === 1
+	&& node.params[0].type === 'Identifier'
+	&& !node.params[0].optional
+	&& node.body.type !== 'BlockStatement';
+
+const isEmptyArrayExpression = node =>
+	node.type === 'ArrayExpression'
+	&& node.elements.length === 0;
+
+const getSingleArrayElement = node => {
+	if (
+		node.type !== 'ArrayExpression'
+		|| node.elements.length !== 1
+		|| !node.elements[0]
+		|| node.elements[0].type === 'SpreadElement'
+	) {
+		return;
+	}
+
+	return node.elements[0];
+};
+
+function shouldParenthesizeArrowBody(node, context) {
+	if (isParenthesized(node, context)) {
+		return false;
+	}
+
+	if (arrowBodyNeedsParenthesesTypes.has(node.type)) {
+		return true;
+	}
+
+	return typescriptExpressionWrapperTypes.has(node.type) && shouldParenthesizeArrowBody(node.expression, context);
+}
+
+function getCallbackResult(callback) {
+	const directElement = getSingleArrayElement(callback.body);
+	if (directElement) {
+		return {
+			type: 'map',
+			element: directElement,
+			arrayExpression: callback.body,
+		};
+	}
+
+	if (callback.body.type !== 'ConditionalExpression') {
+		return;
+	}
+
+	const {test, consequent, alternate} = callback.body;
+	const element = getSingleArrayElement(consequent);
+	if (!element || !isEmptyArrayExpression(alternate)) {
+		return;
+	}
+
+	return {
+		type: 'conditional',
+		test,
+		element,
+		arrayExpression: consequent,
+	};
+}
+
+function getArrowBodyText(node, context) {
+	if (isParenthesized(node, context)) {
+		return getParenthesizedText(node, context);
+	}
+
+	const text = context.sourceCode.getText(node);
+	return shouldParenthesizeArrowBody(node, context)
+		? `(${text})`
+		: text;
+}
+
+function getMemberExpressionObjectText(node, context) {
+	if (node.type === 'Super') {
+		return 'super';
+	}
+
+	if (isParenthesized(node, context)) {
+		return getParenthesizedText(node, context);
+	}
+
+	const text = context.sourceCode.getText(node);
+	return shouldAddParenthesesToMemberExpressionObject(node, context) ? `(${text})` : text;
+}
+
+function getArrowParameterText(callback, context) {
+	const parameterText = context.sourceCode.getText(callback.params[0]);
+	return callback.params[0].typeAnnotation ? `(${parameterText})` : parameterText;
+}
+
+function getFilterMapSuggestion(flatMapCallExpression, callback, callbackResult, context) {
+	if (
+		hasTypeArguments(flatMapCallExpression)
+		|| callback.params[0].typeAnnotation
+		|| wouldRemoveComments(context, flatMapCallExpression, [
+			flatMapCallExpression.callee.object,
+			callbackResult.test,
+			callbackResult.element,
+		])
+		|| hasSideEffect(callbackResult.test, context.sourceCode)
+		|| hasSideEffect(callbackResult.element, context.sourceCode)
+	) {
+		return;
+	}
+
+	const arrayText = getMemberExpressionObjectText(flatMapCallExpression.callee.object, context);
+	const parameterText = getArrowParameterText(callback, context);
+	const testText = getArrowBodyText(callbackResult.test, context);
+	const elementText = getArrowBodyText(callbackResult.element, context);
+
+	return {
+		messageId: SUGGESTION_ID_FILTER_MAP,
+		fix: fixer => fixer.replaceText(
+			flatMapCallExpression,
+			`${arrayText}.filter(${parameterText} => ${testText}).map(${parameterText} => ${elementText})`,
+		),
+	};
+}
+
+function getProblemForFilterFlatMap(flatMapCallExpression, callbackResult, context) {
+	const filterCallExpression = flatMapCallExpression.callee.object;
+	if (!isFilterCallExpression(filterCallExpression)) {
+		return;
+	}
+
+	const problem = {
+		node: flatMapCallExpression.callee.property,
+		messageId: MESSAGE_ID,
+		data: {method: 'map'},
+	};
+
+	if (
+		hasTypeArguments(filterCallExpression)
+		|| hasTypeArguments(flatMapCallExpression)
+		|| isKnownNonArray(filterCallExpression.callee.object, context)
+		|| wouldRemoveComments(context, callbackResult.arrayExpression, [callbackResult.element])
+	) {
+		return problem;
+	}
+
+	return {
+		...problem,
+		* fix(fixer) {
+			yield fixer.replaceText(flatMapCallExpression.callee.property, 'map');
+			yield fixer.replaceText(callbackResult.arrayExpression, getArrowBodyText(callbackResult.element, context));
+		},
+	};
+}
+
+function getProblemForConditionalFlatMap(flatMapCallExpression, callback, callbackResult, context) {
+	const method = isSameIdentifier(callbackResult.element, callback.params[0]) ? 'filter' : 'filter().map';
+	const problem = {
+		node: flatMapCallExpression.callee.property,
+		messageId: MESSAGE_ID,
+		data: {method},
+	};
+
+	if (method === 'filter') {
+		if (
+			hasTypeArguments(flatMapCallExpression)
+			|| hasSideEffect(callbackResult.test, context.sourceCode)
+			|| wouldRemoveComments(context, flatMapCallExpression, [
+				flatMapCallExpression.callee.object,
+				callback.params[0],
+				callbackResult.test,
+			])
+		) {
+			return problem;
+		}
+
+		const arrayText = getMemberExpressionObjectText(flatMapCallExpression.callee.object, context);
+		const parameterText = getArrowParameterText(callback, context);
+		const testText = getArrowBodyText(callbackResult.test, context);
+
+		return {
+			...problem,
+			fix: fixer => fixer.replaceText(
+				flatMapCallExpression,
+				`${arrayText}.filter(${parameterText} => ${testText})`,
+			),
+		};
+	}
+
+	const suggestion = getFilterMapSuggestion(flatMapCallExpression, callback, callbackResult, context);
+	return suggestion
+		? {
+			...problem,
+			suggest: [suggestion],
+		}
+		: problem;
+}
+
+function getProblem(flatMapCallExpression, context) {
+	if (
+		!isMethodCall(flatMapCallExpression, {
+			method: 'flatMap',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+			computed: false,
+		})
+		|| isKnownNonArray(flatMapCallExpression.callee.object, context)
+	) {
+		return;
+	}
+
+	const filterCallExpression = flatMapCallExpression.callee.object;
+	if (
+		isFilterCallExpression(filterCallExpression)
+		&& isKnownNonArray(filterCallExpression.callee.object, context)
+	) {
+		return;
+	}
+
+	const [callback] = flatMapCallExpression.arguments;
+	if (!isSimpleSingleParameterArrowCallback(callback)) {
+		return;
+	}
+
+	const callbackResult = getCallbackResult(callback);
+	if (!callbackResult) {
+		return;
+	}
+
+	if (callbackResult.type === 'map') {
+		return getProblemForFilterFlatMap(flatMapCallExpression, callbackResult, context) ?? {
+			node: flatMapCallExpression.callee.property,
+			messageId: MESSAGE_ID,
+			data: {method: 'map'},
+		};
+	}
+
+	return getProblemForConditionalFlatMap(flatMapCallExpression, callback, callbackResult, context);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('CallExpression', callExpression => getProblem(callExpression, context));
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow `Array#flatMap()` callbacks that only wrap a single item.',
+			recommended: true,
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema: [],
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-unnecessary-await.js

@@ -1,4 +1,4 @@
-import {addParenthesizesToReturnOrThrowExpression, removeSpacesAfter} from './fix/index.js';
+import {addParenthesesToReturnOrThrowExpression, removeSpacesAfter} from './fix/index.js';
 import {isParenthesized, needsSemicolon, isOnSameLine} from './utils/index.js';
 
 const MESSAGE_ID = 'no-unnecessary-await';
@@ -74,7 +74,7 @@ const create = context => {
 					!isOnSameLine(awaitToken, valueNode, context)
 					&& !isParenthesized(node, context)
 				) {
-					yield addParenthesizesToReturnOrThrowExpression(fixer, node.parent, context);
+					yield addParenthesesToReturnOrThrowExpression(fixer, node.parent, context);
 				}
 
 				yield fixer.remove(awaitToken);