eslint-plugin-unicorn 50.0.0 → 51.0.0

package/configs/recommended.js

@@ -2,7 +2,7 @@
 module.exports = {
 	'unicorn/better-regex': 'error',
 	'unicorn/catch-error-name': 'error',
-	'unicorn/consistent-destructuring': 'error',
+	'unicorn/consistent-destructuring': 'off',
 	'unicorn/consistent-function-scoping': 'error',
 	'unicorn/custom-error-definition': 'off',
 	'unicorn/empty-brace-spaces': 'error',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "50.0.0",
+	"version": "51.0.0",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -77,7 +77,7 @@
 		"chalk": "^5.3.0",
 		"enquirer": "^2.4.1",
 		"eslint": "^8.56.0",
-		"eslint-ava-rule-tester": "^4.2.0",
+		"eslint-ava-rule-tester": "^5.0.1",
 		"eslint-doc-generator": "^1.6.1",
 		"eslint-plugin-eslint-plugin": "^5.2.1",
 		"eslint-plugin-internal-rules": "file:./scripts/internal-rules/",
@@ -91,6 +91,7 @@
 		"npm-package-json-lint": "^7.1.0",
 		"npm-run-all2": "^6.1.1",
 		"outdent": "^0.8.0",
+		"pretty-ms": "^8.0.0",
 		"typescript": "^5.3.3",
 		"vue-eslint-parser": "^9.3.2",
 		"xo": "^0.56.0",

package/readme.md

@@ -112,7 +112,7 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | :----------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- |
 | [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-destructuring](docs/rules/consistent-destructuring.md)                               | Use destructured variables over properties.                                                                                                                                                                       |    | 🔧 | 💡 |
 | [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.                                                                                                                                                                                 | ✅  | 🔧 |    |
@@ -244,7 +244,7 @@ import eslintPluginUnicorn from 'eslint-plugin-unicorn';
 
 export default [
 		// …
-		eslintPluginUnicorn.config['flat/recommended'],
+		eslintPluginUnicorn.configs['flat/recommended'],
 		{
 			rules: {
 				'unicorn/better-regex': 'warn',
@@ -261,7 +261,7 @@ const eslintPluginUnicorn = require('eslint-plugin-unicorn');
 
 module.exports = [
 		// …
-		eslintPluginUnicorn.config['flat/recommended'],
+		eslintPluginUnicorn.configs['flat/recommended'],
 		{
 			rules: {
 				'unicorn/better-regex': 'warn',
@@ -281,7 +281,7 @@ import eslintPluginUnicorn from 'eslint-plugin-unicorn';
 
 export default [
 		// …
-		eslintPluginUnicorn.config['flat/all'],
+		eslintPluginUnicorn.configs['flat/all'],
 		{
 			rules: {
 				'unicorn/better-regex': 'warn',
@@ -298,7 +298,7 @@ const eslintPluginUnicorn = require('eslint-plugin-unicorn');
 
 module.exports = [
 		// …
-		eslintPluginUnicorn.config['flat/all'],
+		eslintPluginUnicorn.configs['flat/all'],
 		{
 			rules: {
 				'unicorn/better-regex': 'warn',

package/rules/no-array-method-this-argument.js

@@ -7,12 +7,14 @@ const {isNodeMatches} = require('./utils/is-node-matches.js');
 const {isNodeValueNotFunction} = require('./utils/index.js');
 const {isMethodCall} = require('./ast/index.js');
 
-const ERROR = 'error';
+const ERROR_PROTOTYPE_METHOD = 'error-prototype-method';
+const ERROR_STATIC_METHOD = 'error-static-method';
 const SUGGESTION_BIND = 'suggestion-bind';
 const SUGGESTION_REMOVE = 'suggestion-remove';
 const messages = {
-	[ERROR]: 'Do not use the `this` argument in `Array#{{method}}()`.',
-	[SUGGESTION_REMOVE]: 'Remove the second argument.',
+	[ERROR_PROTOTYPE_METHOD]: 'Do not use the `this` argument in `Array#{{method}}()`.',
+	[ERROR_STATIC_METHOD]: 'Do not use the `this` argument in `Array.{{method}}()`.',
+	[SUGGESTION_REMOVE]: 'Remove this argument.',
 	[SUGGESTION_BIND]: 'Use a bound function.',
 };
 
@@ -70,107 +72,141 @@ const ignored = [
 	'underscore.some',
 ];
 
-function removeThisArgument(callExpression, sourceCode) {
-	return fixer => removeArgument(fixer, callExpression.arguments[1], sourceCode);
+function removeThisArgument(thisArgumentNode, sourceCode) {
+	return fixer => removeArgument(fixer, thisArgumentNode, sourceCode);
 }
 
-function useBoundFunction(callExpression, sourceCode) {
+function useBoundFunction(callbackNode, thisArgumentNode, sourceCode) {
 	return function * (fixer) {
-		yield removeThisArgument(callExpression, sourceCode)(fixer);
+		yield removeThisArgument(thisArgumentNode, sourceCode)(fixer);
 
-		const [callback, thisArgument] = callExpression.arguments;
-
-		const callbackParentheses = getParentheses(callback, sourceCode);
+		const callbackParentheses = getParentheses(callbackNode, sourceCode);
 		const isParenthesized = callbackParentheses.length > 0;
 		const callbackLastToken = isParenthesized
 			? callbackParentheses.at(-1)
-			: callback;
+			: callbackNode;
 		if (
 			!isParenthesized
-			&& shouldAddParenthesesToMemberExpressionObject(callback, sourceCode)
+			&& shouldAddParenthesesToMemberExpressionObject(callbackNode, sourceCode)
 		) {
 			yield fixer.insertTextBefore(callbackLastToken, '(');
 			yield fixer.insertTextAfter(callbackLastToken, ')');
 		}
 
-		const thisArgumentText = getParenthesizedText(thisArgument, sourceCode);
+		const thisArgumentText = getParenthesizedText(thisArgumentNode, sourceCode);
 		// `thisArgument` was a argument, no need add extra parentheses
 		yield fixer.insertTextAfter(callbackLastToken, `.bind(${thisArgumentText})`);
 	};
 }
 
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-
-	return {
-		CallExpression(callExpression) {
-			if (
-				!isMethodCall(callExpression, {
-					methods: [
-						'every',
-						'filter',
-						'find',
-						'findLast',
-						'findIndex',
-						'findLastIndex',
-						'flatMap',
-						'forEach',
-						'map',
-						'some',
-					],
-					argumentsLength: 2,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				|| isNodeMatches(callExpression.callee, ignored)
-				|| isNodeValueNotFunction(callExpression.arguments[0])
-			) {
-				return;
-			}
-
-			const {callee} = callExpression;
-			const method = callee.property.name;
-			const [callback, thisArgument] = callExpression.arguments;
-
-			const problem = {
-				node: thisArgument,
-				messageId: ERROR,
-				data: {method},
-			};
-
-			const thisArgumentHasSideEffect = hasSideEffect(thisArgument, sourceCode);
-			const isArrowCallback = callback.type === 'ArrowFunctionExpression';
-
-			if (isArrowCallback) {
-				if (thisArgumentHasSideEffect) {
-					problem.suggest = [
-						{
-							messageId: SUGGESTION_REMOVE,
-							fix: removeThisArgument(callExpression, sourceCode),
-						},
-					];
-				} else {
-					problem.fix = removeThisArgument(callExpression, sourceCode);
-				}
-
-				return problem;
-			}
+function getProblem({
+	sourceCode,
+	callExpression,
+	callbackNode,
+	thisArgumentNode,
+	messageId,
+}) {
+	const problem = {
+		node: thisArgumentNode,
+		messageId,
+		data: {
+			method: callExpression.callee.property.name,
+		},
+	};
 
+	const isArrowCallback = callbackNode.type === 'ArrowFunctionExpression';
+	if (isArrowCallback) {
+		const thisArgumentHasSideEffect = hasSideEffect(thisArgumentNode, sourceCode);
+		if (thisArgumentHasSideEffect) {
 			problem.suggest = [
 				{
 					messageId: SUGGESTION_REMOVE,
-					fix: removeThisArgument(callExpression, sourceCode),
-				},
-				{
-					messageId: SUGGESTION_BIND,
-					fix: useBoundFunction(callExpression, sourceCode),
+					fix: removeThisArgument(thisArgumentNode, sourceCode),
 				},
 			];
+		} else {
+			problem.fix = removeThisArgument(thisArgumentNode, sourceCode);
+		}
+
+		return problem;
+	}
 
-			return problem;
+	problem.suggest = [
+		{
+			messageId: SUGGESTION_REMOVE,
+			fix: removeThisArgument(thisArgumentNode, sourceCode),
 		},
-	};
+		{
+			messageId: SUGGESTION_BIND,
+			fix: useBoundFunction(callbackNode, thisArgumentNode, sourceCode),
+		},
+	];
+
+	return problem;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	// Prototype methods
+	context.on('CallExpression', callExpression => {
+		if (
+			!isMethodCall(callExpression, {
+				methods: [
+					'every',
+					'filter',
+					'find',
+					'findLast',
+					'findIndex',
+					'findLastIndex',
+					'flatMap',
+					'forEach',
+					'map',
+					'some',
+				],
+				argumentsLength: 2,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			|| isNodeMatches(callExpression.callee, ignored)
+			|| isNodeValueNotFunction(callExpression.arguments[0])
+		) {
+			return;
+		}
+
+		return getProblem({
+			sourceCode,
+			callExpression,
+			callbackNode: callExpression.arguments[0],
+			thisArgumentNode: callExpression.arguments[1],
+			messageId: ERROR_PROTOTYPE_METHOD,
+		});
+	});
+
+	// `Array.from()`
+	context.on('CallExpression', callExpression => {
+		if (
+			!isMethodCall(callExpression, {
+				object: 'Array',
+				method: 'from',
+				argumentsLength: 3,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			|| isNodeValueNotFunction(callExpression.arguments[1])
+		) {
+			return;
+		}
+
+		return getProblem({
+			sourceCode,
+			callExpression,
+			callbackNode: callExpression.arguments[1],
+			thisArgumentNode: callExpression.arguments[2],
+			messageId: ERROR_STATIC_METHOD,
+		});
+	});
 };
 
 /** @type {import('eslint').Rule.RuleModule} */

package/rules/no-thenable.js

@@ -13,6 +13,15 @@ const messages = {
 
 const isStringThen = (node, context) =>
 	getStaticValue(node, context.sourceCode.getScope(node))?.value === 'then';
+const isPropertyThen = (node, context) => {
+	// `getPropertyName` throws on `({[Symbol.prototype]: 0})`
+	// https://github.com/eslint-community/eslint-utils/pull/182
+	try {
+		return getPropertyName(node, context.sourceCode.getScope(node)) === 'then';
+	} catch {}
+
+	return false;
+};
 
 const cases = [
 	// `{then() {}}`,
@@ -23,10 +32,7 @@ const cases = [
 		selector: 'ObjectExpression',
 		* getNodes(node, context) {
 			for (const property of node.properties) {
-				if (
-					property.type === 'Property'
-					&& getPropertyName(property, context.sourceCode.getScope(property)) === 'then'
-				) {
+				if (property.type === 'Property' && isPropertyThen(property, context)) {
 					yield property.key;
 				}
 			}

package/rules/no-unnecessary-polyfills.js

@@ -2,7 +2,7 @@
 const path = require('node:path');
 const readPkgUp = require('read-pkg-up');
 const coreJsCompat = require('core-js-compat');
-const {camelCase} = require('lodash');
+const {camelCase} = require('./utils/lodash.js');
 const isStaticRequire = require('./ast/is-static-require.js');
 
 const {data: compatData, entries: coreJsEntries} = coreJsCompat;

package/rules/prefer-module.js

@@ -13,8 +13,10 @@ const ERROR_USE_STRICT_DIRECTIVE = 'error/use-strict-directive';
 const ERROR_GLOBAL_RETURN = 'error/global-return';
 const ERROR_IDENTIFIER = 'error/identifier';
 const SUGGESTION_USE_STRICT_DIRECTIVE = 'suggestion/use-strict-directive';
-const SUGGESTION_DIRNAME = 'suggestion/dirname';
-const SUGGESTION_FILENAME = 'suggestion/filename';
+const SUGGESTION_IMPORT_META_DIRNAME = 'suggestion/import-meta-dirname';
+const SUGGESTION_IMPORT_META_URL_TO_DIRNAME = 'suggestion/import-meta-url-to-dirname';
+const SUGGESTION_IMPORT_META_FILENAME = 'suggestion/import-meta-filename';
+const SUGGESTION_IMPORT_META_URL_TO_FILENAME = 'suggestion/import-meta-url-to-filename';
 const SUGGESTION_IMPORT = 'suggestion/import';
 const SUGGESTION_EXPORT = 'suggestion/export';
 const messages = {
@@ -22,12 +24,43 @@ const messages = {
 	[ERROR_GLOBAL_RETURN]: '"return" should be used inside a function.',
 	[ERROR_IDENTIFIER]: 'Do not use "{{name}}".',
 	[SUGGESTION_USE_STRICT_DIRECTIVE]: 'Remove "use strict" directive.',
-	[SUGGESTION_DIRNAME]: 'Replace "__dirname" with `"…(import.meta.url)"`.',
-	[SUGGESTION_FILENAME]: 'Replace "__filename" with `"…(import.meta.url)"`.',
+	[SUGGESTION_IMPORT_META_DIRNAME]: 'Replace `__dirname` with `import.meta.dirname`.',
+	[SUGGESTION_IMPORT_META_URL_TO_DIRNAME]: 'Replace `__dirname` with `…(import.meta.url)`.',
+	[SUGGESTION_IMPORT_META_FILENAME]: 'Replace `__dirname` with `import.meta.filename`.',
+	[SUGGESTION_IMPORT_META_URL_TO_FILENAME]: 'Replace `__filename` with `…(import.meta.url)`.',
 	[SUGGESTION_IMPORT]: 'Switch to `import`.',
 	[SUGGESTION_EXPORT]: 'Switch to `export`.',
 };
 
+const suggestions = new Map([
+	[
+		'__dirname',
+		[
+			{
+				messageId: SUGGESTION_IMPORT_META_DIRNAME,
+				replacement: 'import.meta.dirname',
+			},
+			{
+				messageId: SUGGESTION_IMPORT_META_URL_TO_DIRNAME,
+				replacement: 'path.dirname(url.fileURLToPath(import.meta.url))',
+			},
+		],
+	],
+	[
+		'__filename',
+		[
+			{
+				messageId: SUGGESTION_IMPORT_META_FILENAME,
+				replacement: 'import.meta.filename',
+			},
+			{
+				messageId: SUGGESTION_IMPORT_META_URL_TO_FILENAME,
+				replacement: 'url.fileURLToPath(import.meta.url)',
+			},
+		],
+	],
+]);
+
 function fixRequireCall(node, sourceCode) {
 	if (!isStaticRequire(node.parent) || node.parent.callee !== node) {
 		return;
@@ -277,14 +310,12 @@ function create(context) {
 		switch (name) {
 			case '__filename':
 			case '__dirname': {
-				const messageId = node.name === '__dirname' ? SUGGESTION_DIRNAME : SUGGESTION_FILENAME;
-				const replacement = node.name === '__dirname'
-					? 'path.dirname(url.fileURLToPath(import.meta.url))'
-					: 'url.fileURLToPath(import.meta.url)';
-				problem.suggest = [{
-					messageId,
-					fix: fixer => replaceReferenceIdentifier(node, replacement, fixer),
-				}];
+				problem.suggest = suggestions.get(node.name)
+					.map(({messageId, replacement}) => ({
+						messageId,
+						fix: fixer => replaceReferenceIdentifier(node, replacement, fixer),
+					}));
+
 				return problem;
 			}
 

package/rules/prefer-prototype-methods.js

@@ -30,7 +30,7 @@ function create(context) {
 				// `[].foo.{apply,bind,call}(…)`
 				// `({}).foo.{apply,bind,call}(…)`
 				isMethodCall(callExpression, {
-					names: ['apply', 'bind', 'call'],
+					methods: ['apply', 'bind', 'call'],
 					optionalCall: false,
 					optionalMember: false,
 				})

package/rules/shared/abbreviations.js

@@ -180,9 +180,9 @@ module.exports.defaultReplacements = {
 		request: true,
 	},
 	res: {
+		resource: true,
 		response: true,
 		result: true,
-		resource: true,
 	},
 	ret: {
 		returnValue: true,