eslint-plugin-unicorn 51.0.1 → 52.0.0

package/configs/recommended.js

@@ -14,12 +14,14 @@ module.exports = {
 	'unicorn/import-style': 'error',
 	'unicorn/new-for-builtins': 'error',
 	'unicorn/no-abusive-eslint-disable': 'error',
+	'unicorn/no-anonymous-default-export': 'error',
 	'unicorn/no-array-callback-reference': 'error',
 	'unicorn/no-array-for-each': 'error',
 	'unicorn/no-array-method-this-argument': 'error',
 	'unicorn/no-array-push-push': 'error',
 	'unicorn/no-array-reduce': 'error',
 	'unicorn/no-await-expression-member': 'error',
+	'unicorn/no-await-in-promise-methods': 'error',
 	'unicorn/no-console-spaces': 'error',
 	'unicorn/no-document-cookie': 'error',
 	'unicorn/no-empty-file': 'error',
@@ -38,6 +40,7 @@ module.exports = {
 	'unicorn/no-null': 'error',
 	'unicorn/no-object-as-default-parameter': 'error',
 	'unicorn/no-process-exit': 'error',
+	'unicorn/no-single-promise-in-promise-methods': 'error',
 	'unicorn/no-static-only-class': 'error',
 	'unicorn/no-thenable': 'error',
 	'unicorn/no-this-assignment': 'error',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "51.0.1",
+	"version": "52.0.0",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -78,7 +78,7 @@
 		"enquirer": "^2.4.1",
 		"eslint": "^8.56.0",
 		"eslint-ava-rule-tester": "^5.0.1",
-		"eslint-doc-generator": "^1.6.1",
+		"eslint-doc-generator": "^1.7.0",
 		"eslint-plugin-eslint-plugin": "^5.2.1",
 		"eslint-plugin-internal-rules": "file:./scripts/internal-rules/",
 		"eslint-remote-tester": "^3.0.1",
@@ -134,7 +134,8 @@
 					]
 				}
 			],
-			"import/order": "off"
+			"import/order": "off",
+			"func-names": "off"
 		},
 		"overrides": [
 			{

package/readme.md

@@ -106,7 +106,7 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 💼 [Configurations](https://github.com/sindresorhus/eslint-plugin-unicorn#preset-configs) enabled in.\
 ✅ Set in the `recommended` [configuration](https://github.com/sindresorhus/eslint-plugin-unicorn#preset-configs).\
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
-💡 Manually fixable by [editor suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions).
+💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
 | Name                                                                                             | Description                                                                                                                                                                                                       | 💼 | 🔧 | 💡 |
 | :----------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- |
@@ -124,12 +124,14 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | [import-style](docs/rules/import-style.md)                                                       | Enforce specific import styles per module.                                                                                                                                                                        | ✅  |    |    |
 | [new-for-builtins](docs/rules/new-for-builtins.md)                                               | Enforce the use of `new` for all builtins, except `String`, `Number`, `Boolean`, `Symbol` and `BigInt`.                                                                                                           | ✅  | 🔧 |    |
 | [no-abusive-eslint-disable](docs/rules/no-abusive-eslint-disable.md)                             | Enforce specifying rules to disable in `eslint-disable` comments.                                                                                                                                                 | ✅  |    |    |
+| [no-anonymous-default-export](docs/rules/no-anonymous-default-export.md)                         | Disallow anonymous functions and classes as the default export.                                                                                                                                                   | ✅  |    | 💡 |
 | [no-array-callback-reference](docs/rules/no-array-callback-reference.md)                         | Prevent passing a function reference directly to iterator methods.                                                                                                                                                | ✅  |    | 💡 |
 | [no-array-for-each](docs/rules/no-array-for-each.md)                                             | Prefer `for…of` over the `forEach` method.                                                                                                                                                                        | ✅  | 🔧 | 💡 |
 | [no-array-method-this-argument](docs/rules/no-array-method-this-argument.md)                     | Disallow using the `this` argument in array methods.                                                                                                                                                              | ✅  | 🔧 | 💡 |
 | [no-array-push-push](docs/rules/no-array-push-push.md)                                           | Enforce combining multiple `Array#push()` into one call.                                                                                                                                                          | ✅  | 🔧 | 💡 |
 | [no-array-reduce](docs/rules/no-array-reduce.md)                                                 | Disallow `Array#reduce()` and `Array#reduceRight()`.                                                                                                                                                              | ✅  |    |    |
 | [no-await-expression-member](docs/rules/no-await-expression-member.md)                           | Disallow member access from await expression.                                                                                                                                                                     | ✅  | 🔧 |    |
+| [no-await-in-promise-methods](docs/rules/no-await-in-promise-methods.md)                         | Disallow using `await` in `Promise` method parameters.                                                                                                                                                            | ✅  |    | 💡 |
 | [no-console-spaces](docs/rules/no-console-spaces.md)                                             | Do not use leading/trailing space between `console.log` parameters.                                                                                                                                               | ✅  | 🔧 |    |
 | [no-document-cookie](docs/rules/no-document-cookie.md)                                           | Do not use `document.cookie` directly.                                                                                                                                                                            | ✅  |    |    |
 | [no-empty-file](docs/rules/no-empty-file.md)                                                     | Disallow empty files.                                                                                                                                                                                             | ✅  |    |    |
@@ -146,6 +148,7 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | [no-null](docs/rules/no-null.md)                                                                 | Disallow the use of the `null` literal.                                                                                                                                                                           | ✅  | 🔧 | 💡 |
 | [no-object-as-default-parameter](docs/rules/no-object-as-default-parameter.md)                   | Disallow the use of objects as default parameters.                                                                                                                                                                | ✅  |    |    |
 | [no-process-exit](docs/rules/no-process-exit.md)                                                 | Disallow `process.exit()`.                                                                                                                                                                                        | ✅  |    |    |
+| [no-single-promise-in-promise-methods](docs/rules/no-single-promise-in-promise-methods.md)       | Disallow passing single-element arrays to `Promise` methods.                                                                                                                                                      | ✅  | 🔧 | 💡 |
 | [no-static-only-class](docs/rules/no-static-only-class.md)                                       | Disallow classes that only have static members.                                                                                                                                                                   | ✅  | 🔧 |    |
 | [no-thenable](docs/rules/no-thenable.md)                                                         | Disallow `then` property.                                                                                                                                                                                         | ✅  |    |    |
 | [no-this-assignment](docs/rules/no-this-assignment.md)                                           | Disallow assigning `this` to a variable.                                                                                                                                                                          | ✅  |    |    |

package/rules/filename-case.js

@@ -85,7 +85,7 @@ function validateFilename(words, caseFunctions) {
 		.every(({word}) => caseFunctions.some(caseFunction => caseFunction(word) === word));
 }
 
-function fixFilename(words, caseFunctions, {leading, extension}) {
+function fixFilename(words, caseFunctions, {leading, trailing}) {
 	const replacements = words
 		.map(({word, ignored}) => ignored ? [word] : caseFunctions.map(caseFunction => caseFunction(word)));
 
@@ -93,7 +93,30 @@ function fixFilename(words, caseFunctions, {leading, extension}) {
 		samples: combinations,
 	} = cartesianProductSamples(replacements);
 
-	return [...new Set(combinations.map(parts => `${leading}${parts.join('')}${extension.toLowerCase()}`))];
+	return [...new Set(combinations.map(parts => `${leading}${parts.join('')}${trailing}`))];
+}
+
+function getFilenameParts(filenameWithExtension, {multipleFileExtensions}) {
+	const extension = path.extname(filenameWithExtension);
+	const filename = path.basename(filenameWithExtension, extension);
+	const basename = filename + extension;
+
+	const parts = {
+		basename,
+		filename,
+		middle: '',
+		extension,
+	};
+
+	if (multipleFileExtensions) {
+		const [firstPart] = filename.split('.');
+		Object.assign(parts, {
+			filename: firstPart,
+			middle: filename.slice(firstPart.length),
+		});
+	}
+
+	return parts;
 }
 
 const leadingUnderscoresRegex = /^(?<leading>_+)(?<tailing>.*)$/;
@@ -143,6 +166,7 @@ const create = context => {
 
 		return new RegExp(item, 'u');
 	});
+	const multipleFileExtensions = options.multipleFileExtensions !== false;
 	const chosenCasesFunctions = chosenCases.map(case_ => ignoreNumbers(cases[case_].fn));
 	const filenameWithExtension = context.physicalFilename;
 
@@ -152,11 +176,14 @@ const create = context => {
 
 	return {
 		Program() {
-			const extension = path.extname(filenameWithExtension);
-			const filename = path.basename(filenameWithExtension, extension);
-			const base = filename + extension;
+			const {
+				basename,
+				filename,
+				middle,
+				extension,
+			} = getFilenameParts(filenameWithExtension, {multipleFileExtensions});
 
-			if (ignoredByDefault.has(base) || ignore.some(regexp => regexp.test(base))) {
+			if (ignoredByDefault.has(basename) || ignore.some(regexp => regexp.test(basename))) {
 				return;
 			}
 
@@ -168,7 +195,7 @@ const create = context => {
 					return {
 						loc: {column: 0, line: 1},
 						messageId: MESSAGE_ID_EXTENSION,
-						data: {filename: filename + extension.toLowerCase(), extension},
+						data: {filename: filename + middle + extension.toLowerCase(), extension},
 					};
 				}
 
@@ -177,7 +204,7 @@ const create = context => {
 
 			const renamedFilenames = fixFilename(words, chosenCasesFunctions, {
 				leading,
-				extension,
+				trailing: middle + extension.toLowerCase(),
 			});
 
 			return {
@@ -211,6 +238,9 @@ const schema = [
 						type: 'array',
 						uniqueItems: true,
 					},
+					multipleFileExtensions: {
+						type: 'boolean',
+					},
 				},
 				additionalProperties: false,
 			},
@@ -237,6 +267,9 @@ const schema = [
 						type: 'array',
 						uniqueItems: true,
 					},
+					multipleFileExtensions: {
+						type: 'boolean',
+					},
 				},
 				additionalProperties: false,
 			},

package/rules/import-style.js

@@ -117,9 +117,15 @@ const defaultStyles = {
 	path: {
 		default: true,
 	},
+	'node:path': {
+		default: true,
+	},
 	util: {
 		named: true,
 	},
+	'node:util': {
+		named: true,
+	},
 };
 
 /** @param {import('eslint').Rule.RuleContext} context */

package/rules/no-anonymous-default-export.js

@@ -0,0 +1,212 @@
+'use strict';
+
+const path = require('node:path');
+const {
+	getFunctionHeadLocation,
+	getFunctionNameWithKind,
+	isOpeningParenToken,
+} = require('@eslint-community/eslint-utils');
+const {
+	isIdentifierName,
+} = require('@babel/helper-validator-identifier');
+const getClassHeadLocation = require('./utils/get-class-head-location.js');
+const {upperFirst, camelCase} = require('./utils/lodash.js');
+const {getParenthesizedRange} = require('./utils/parentheses.js');
+const {
+	getScopes,
+	avoidCapture,
+} = require('./utils/index.js');
+const {isMemberExpression} = require('./ast/index.js');
+
+const MESSAGE_ID_ERROR = 'no-anonymous-default-export/error';
+const MESSAGE_ID_SUGGESTION = 'no-anonymous-default-export/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'The {{description}} should be named.',
+	[MESSAGE_ID_SUGGESTION]: 'Name it as `{{name}}`.',
+};
+
+const isClassKeywordToken = token => token.type === 'Keyword' && token.value === 'class';
+const isAnonymousClassOrFunction = node =>
+	(
+		(
+			node.type === 'FunctionDeclaration'
+			|| node.type === 'FunctionExpression'
+			|| node.type === 'ClassDeclaration'
+			|| node.type === 'ClassExpression'
+		)
+		&& !node.id
+	)
+	|| node.type === 'ArrowFunctionExpression';
+
+function getSuggestionName(node, filename, sourceCode) {
+	if (filename === '<input>' || filename === '<text>') {
+		return;
+	}
+
+	let [name] = path.basename(filename).split('.');
+	name = camelCase(name);
+
+	if (!isIdentifierName(name)) {
+		return;
+	}
+
+	name = node.type === 'ClassDeclaration' || node.type === 'ClassExpression' ? upperFirst(name) : name;
+	name = avoidCapture(name, getScopes(sourceCode.getScope(node)));
+
+	return name;
+}
+
+function addName(fixer, node, name, sourceCode) {
+	switch (node.type) {
+		case 'ClassDeclaration':
+		case 'ClassExpression': {
+			const lastDecorator = node.decorators?.at(-1);
+			const classToken = lastDecorator
+				? sourceCode.getTokenAfter(lastDecorator, isClassKeywordToken)
+				: sourceCode.getFirstToken(node, isClassKeywordToken);
+			return fixer.insertTextAfter(classToken, ` ${name}`);
+		}
+
+		case 'FunctionDeclaration':
+		case 'FunctionExpression': {
+			const openingParenthesisToken = sourceCode.getFirstToken(
+				node,
+				isOpeningParenToken,
+			);
+			return fixer.insertTextBefore(
+				openingParenthesisToken,
+				`${sourceCode.text.charAt(openingParenthesisToken.range[0] - 1) === ' ' ? '' : ' '}${name} `,
+			);
+		}
+
+		case 'ArrowFunctionExpression': {
+			const [exportDeclarationStart, exportDeclarationEnd]
+				= node.parent.type === 'ExportDefaultDeclaration'
+					? node.parent.range
+					: node.parent.parent.range;
+			const [arrowFunctionStart, arrowFunctionEnd] = getParenthesizedRange(node, sourceCode);
+
+			let textBefore = sourceCode.text.slice(exportDeclarationStart, arrowFunctionStart);
+			let textAfter = sourceCode.text.slice(arrowFunctionEnd, exportDeclarationEnd);
+
+			textBefore = `\n${textBefore}`;
+			if (!/\s$/.test(textBefore)) {
+				textBefore = `${textBefore} `;
+			}
+
+			if (!textAfter.endsWith(';')) {
+				textAfter = `${textAfter};`;
+			}
+
+			return [
+				fixer.replaceTextRange(
+					[exportDeclarationStart, arrowFunctionStart],
+					`const ${name} = `,
+				),
+				fixer.replaceTextRange(
+					[arrowFunctionEnd, exportDeclarationEnd],
+					';',
+				),
+				fixer.insertTextAfterRange(
+					[exportDeclarationEnd, exportDeclarationEnd],
+					`${textBefore}${name}${textAfter}`,
+				),
+			];
+		}
+
+		// No default
+	}
+}
+
+function getProblem(node, context) {
+	const {sourceCode, physicalFilename} = context;
+
+	const suggestionName = getSuggestionName(node, physicalFilename, sourceCode);
+
+	let loc;
+	let description;
+	if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+		loc = getClassHeadLocation(node, sourceCode);
+		description = 'class';
+	} else {
+		loc = getFunctionHeadLocation(node, sourceCode);
+		// [TODO: @fisker]: Ask `@eslint-community/eslint-utils` to expose `getFunctionKind`
+		const nameWithKind = getFunctionNameWithKind(node);
+		description = nameWithKind.replace(/ '.*?'$/, '');
+	}
+
+	const problem = {
+		node,
+		loc,
+		messageId: MESSAGE_ID_ERROR,
+		data: {
+			description,
+		},
+	};
+
+	if (!suggestionName) {
+		return problem;
+	}
+
+	problem.suggest = [
+		{
+			messageId: MESSAGE_ID_SUGGESTION,
+			data: {
+				name: suggestionName,
+			},
+			fix: fixer => addName(fixer, node, suggestionName, sourceCode),
+		},
+	];
+
+	return problem;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('ExportDefaultDeclaration', node => {
+		if (!isAnonymousClassOrFunction(node.declaration)) {
+			return;
+		}
+
+		return getProblem(node.declaration, context);
+	});
+
+	context.on('AssignmentExpression', node => {
+		if (
+			!isAnonymousClassOrFunction(node.right)
+			|| !(
+				node.parent.type === 'ExpressionStatement'
+				&& node.parent.expression === node
+			)
+			|| !(
+				isMemberExpression(node.left, {
+					object: 'module',
+					property: 'exports',
+					computed: false,
+					optional: false,
+				})
+				|| (
+					node.left.type === 'Identifier',
+					node.left.name === 'exports'
+				)
+			)
+		) {
+			return;
+		}
+
+		return getProblem(node.right, context);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow anonymous functions and classes as the default export.',
+		},
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/no-array-callback-reference.js

@@ -1,7 +1,13 @@
 'use strict';
-const {isParenthesized} = require('@eslint-community/eslint-utils');
 const {isMethodCall} = require('./ast/index.js');
-const {isNodeMatches, isNodeValueNotFunction} = require('./utils/index.js');
+const {
+	isNodeMatches,
+	isNodeValueNotFunction,
+	isParenthesized,
+	getParenthesizedRange,
+	getParenthesizedText,
+	shouldAddParenthesesToCallExpressionCallee,
+} = require('./utils/index.js');
 
 const ERROR_WITH_NAME_MESSAGE_ID = 'error-with-name';
 const ERROR_WITHOUT_NAME_MESSAGE_ID = 'error-without-name';
@@ -25,7 +31,7 @@ const iteratorMethods = new Map([
 	},
 	{
 		method: 'filter',
-		test: node => !(node.callee.object.type === 'Identifier' && node.callee.object.name === 'Vue'),
+		shouldIgnoreCallExpression: node => (node.callee.object.type === 'Identifier' && node.callee.object.name === 'Vue'),
 		ignore: [
 			'Boolean',
 		],
@@ -63,7 +69,7 @@ const iteratorMethods = new Map([
 	},
 	{
 		method: 'map',
-		test: node => !(node.callee.object.type === 'Identifier' && node.callee.object.name === 'types'),
+		shouldIgnoreCallExpression: node => (node.callee.object.type === 'Identifier' && node.callee.object.name === 'types'),
 		ignore: [
 			'String',
 			'Number',
@@ -104,35 +110,39 @@ const iteratorMethods = new Map([
 	ignore = [],
 	minParameters = 1,
 	returnsUndefined = false,
-	test,
+	shouldIgnoreCallExpression,
 }) => [method, {
 	minParameters,
 	parameters,
 	returnsUndefined,
-	test(node) {
+	shouldIgnoreCallExpression(callExpression) {
 		if (
 			method !== 'reduce'
 			&& method !== 'reduceRight'
-			&& isAwaitExpressionArgument(node)
+			&& isAwaitExpressionArgument(callExpression)
 		) {
-			return false;
+			return true;
 		}
 
-		if (isNodeMatches(node.callee.object, ignoredCallee)) {
-			return false;
+		if (isNodeMatches(callExpression.callee.object, ignoredCallee)) {
+			return true;
 		}
 
-		if (node.callee.object.type === 'CallExpression' && isNodeMatches(node.callee.object.callee, ignoredCallee)) {
-			return false;
+		if (
+			callExpression.callee.object.type === 'CallExpression'
+			&& isNodeMatches(callExpression.callee.object.callee, ignoredCallee)
+		) {
+			return true;
 		}
 
-		const [callback] = node.arguments;
-
+		return shouldIgnoreCallExpression?.(callExpression) ?? false;
+	},
+	shouldIgnoreCallback(callback) {
 		if (callback.type === 'Identifier' && ignore.includes(callback.name)) {
-			return false;
+			return true;
 		}
 
-		return !test || test(node);
+		return false;
 	},
 }]));
 
@@ -163,9 +173,14 @@ function getProblem(context, node, method, options) {
 			name,
 			method,
 		},
-		suggest: [],
 	};
 
+	if (node.type === 'YieldExpression' || node.type === 'AwaitExpression') {
+		return problem;
+	}
+
+	problem.suggest = [];
+
 	const {parameters, minParameters, returnsUndefined} = options;
 	for (let parameterLength = minParameters; parameterLength <= parameters.length; parameterLength++) {
 		const suggestionParameters = parameters.slice(0, parameterLength).join(', ');
@@ -178,16 +193,20 @@ function getProblem(context, node, method, options) {
 			},
 			fix(fixer) {
 				const {sourceCode} = context;
-				let nodeText = sourceCode.getText(node);
-				if (isParenthesized(node, sourceCode) || type === 'ConditionalExpression') {
-					nodeText = `(${nodeText})`;
+				let text = getParenthesizedText(node, sourceCode);
+
+				if (
+					!isParenthesized(node, sourceCode)
+					&& shouldAddParenthesesToCallExpressionCallee(node)
+				) {
+					text = `(${text})`;
 				}
 
-				return fixer.replaceText(
-					node,
+				return fixer.replaceTextRange(
+					getParenthesizedRange(node, sourceCode),
 					returnsUndefined
-						? `(${suggestionParameters}) => { ${nodeText}(${suggestionParameters}); }`
-						: `(${suggestionParameters}) => ${nodeText}(${suggestionParameters})`,
+						? `(${suggestionParameters}) => { ${text}(${suggestionParameters}); }`
+						: `(${suggestionParameters}) => ${text}(${suggestionParameters})`,
 				);
 			},
 		};
@@ -198,47 +217,57 @@ function getProblem(context, node, method, options) {
 	return problem;
 }
 
+function * getTernaryConsequentAndALternate(node) {
+	if (node.type === 'ConditionalExpression') {
+		yield * getTernaryConsequentAndALternate(node.consequent);
+		yield * getTernaryConsequentAndALternate(node.alternate);
+		return;
+	}
+
+	yield node;
+}
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => ({
-	CallExpression(node) {
+	* CallExpression(callExpression) {
 		if (
-			!isMethodCall(node, {
+			!isMethodCall(callExpression, {
 				minimumArguments: 1,
 				maximumArguments: 2,
 				optionalCall: false,
 				optionalMember: false,
 				computed: false,
 			})
-			|| node.callee.property.type !== 'Identifier'
+			|| callExpression.callee.property.type !== 'Identifier'
 		) {
 			return;
 		}
 
-		const methodNode = node.callee.property;
+		const methodNode = callExpression.callee.property;
 		const methodName = methodNode.name;
 		if (!iteratorMethods.has(methodName)) {
 			return;
 		}
 
-		const [callback] = node.arguments;
-
-		if (
-			callback.type === 'FunctionExpression'
-			|| callback.type === 'ArrowFunctionExpression'
-			// Ignore all `CallExpression`s include `function.bind()`
-			|| callback.type === 'CallExpression'
-			|| isNodeValueNotFunction(callback)
-		) {
+		const options = iteratorMethods.get(methodName);
+		if (options.shouldIgnoreCallExpression(callExpression)) {
 			return;
 		}
 
-		const options = iteratorMethods.get(methodName);
+		for (const callback of getTernaryConsequentAndALternate(callExpression.arguments[0])) {
+			if (
+				callback.type === 'FunctionExpression'
+				|| callback.type === 'ArrowFunctionExpression'
+				// Ignore all `CallExpression`s include `function.bind()`
+				|| callback.type === 'CallExpression'
+				|| options.shouldIgnoreCallback(callback)
+				|| isNodeValueNotFunction(callback)
+			) {
+				continue;
+			}
 
-		if (!options.test(node)) {
-			return;
+			yield getProblem(context, callback, methodName, options);
 		}
-
-		return getProblem(context, callback, methodName, options);
 	},
 });