eslint-plugin-unicorn 62.0.0 → 64.0.0

package/index.d.ts

@@ -2,15 +2,15 @@ import type {ESLint, Linter} from 'eslint';
 
 declare const eslintPluginUnicorn: ESLint.Plugin & {
 	configs: {
-		recommended: Linter.FlatConfig;
-		unopinionated: Linter.FlatConfig;
-		all: Linter.FlatConfig;
+		recommended: Linter.Config;
+		unopinionated: Linter.Config;
+		all: Linter.Config;
 
 		/** @deprecated Use `all` instead. The `flat/` prefix is no longer needed. */
-		'flat/all': Linter.FlatConfig;
+		'flat/all': Linter.Config;
 
 		/** @deprecated Use `recommended` instead. The `flat/` prefix is no longer needed. */
-		'flat/recommended': Linter.FlatConfig;
+		'flat/recommended': Linter.Config;
 	};
 };
 

package/index.js

@@ -1,13 +1,12 @@
 import createDeprecatedRules from './rules/utils/create-deprecated-rules.js';
 import flatConfigBase from './configs/flat-config-base.js';
 import * as rawRules from './rules/index.js';
-import {createRules} from './rules/rule/index.js';
+import {toEslintRules} from './rules/rule/index.js';
 import packageJson from './package.json' with {type: 'json'};
 
-const rules = createRules(rawRules);
+const rules = toEslintRules(rawRules);
 
 const deprecatedRules = createDeprecatedRules({
-	// {ruleId: {message: string, replacedBy: string[]}}
 	'no-instanceof-array': {
 		message: 'Replaced by `unicorn/no-instanceof-builtins` which covers more cases.',
 		replacedBy: ['unicorn/no-instanceof-builtins'],
@@ -29,26 +28,20 @@ const externalRules = {
 	'no-nested-ternary': 'off',
 };
 
-const recommendedRules = Object.fromEntries(
-	Object.entries(rules).map(([id, rule]) => [
-		`unicorn/${id}`,
-		rule.meta.docs.recommended ? 'error' : 'off',
-	]),
-);
+const recommendedRules = Object.fromEntries(Object.entries(rules).map(([id, rule]) => [
+	`unicorn/${id}`,
+	rule.meta.docs.recommended ? 'error' : 'off',
+]));
 
-const unopinionatedRules = Object.fromEntries(
-	Object.entries(rules).map(([id, rule]) => [
-		`unicorn/${id}`,
-		rule.meta.docs.recommended === 'unopinionated' ? 'error' : 'off',
-	]),
-);
+const unopinionatedRules = Object.fromEntries(Object.entries(rules).map(([id, rule]) => [
+	`unicorn/${id}`,
+	rule.meta.docs.recommended === 'unopinionated' ? 'error' : 'off',
+]));
 
-const allRules = Object.fromEntries(
-	Object.keys(rules).map(id => [
-		`unicorn/${id}`,
-		'error',
-	]),
-);
+const allRules = Object.fromEntries(Object.keys(rules).map(id => [
+	`unicorn/${id}`,
+	'error',
+]));
 
 const createConfig = (rules, flatConfigName) => ({
 	...flatConfigBase,
@@ -68,7 +61,7 @@ const unicorn = {
 		version: packageJson.version,
 	},
 	rules: {
-		...createRules(rules),
+		...rules,
 		...deprecatedRules,
 	},
 };
@@ -83,9 +76,6 @@ const configs = {
 	'flat/all': createConfig(allRules, 'unicorn/flat/all'),
 };
 
-const allConfigs = {
-	...unicorn,
-	configs,
-};
+unicorn.configs = configs;
 
-export default allConfigs;
+export default unicorn;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "62.0.0",
+	"version": "64.0.0",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -57,58 +57,54 @@
 	],
 	"dependencies": {
 		"@babel/helper-validator-identifier": "^7.28.5",
-		"@eslint-community/eslint-utils": "^4.9.0",
-		"@eslint/plugin-kit": "^0.4.0",
+		"@eslint-community/eslint-utils": "^4.9.1",
 		"change-case": "^5.4.4",
-		"ci-info": "^4.3.1",
+		"ci-info": "^4.4.0",
 		"clean-regexp": "^1.0.0",
-		"core-js-compat": "^3.46.0",
-		"esquery": "^1.6.0",
+		"core-js-compat": "^3.49.0",
 		"find-up-simple": "^1.0.1",
-		"globals": "^16.4.0",
+		"globals": "^17.4.0",
 		"indent-string": "^5.0.0",
 		"is-builtin-module": "^5.0.0",
 		"jsesc": "^3.1.0",
 		"pluralize": "^8.0.0",
 		"regexp-tree": "^0.1.27",
 		"regjsparser": "^0.13.0",
-		"semver": "^7.7.3",
+		"semver": "^7.7.4",
 		"strip-indent": "^4.1.1"
 	},
 	"devDependencies": {
-		"@babel/code-frame": "^7.27.1",
-		"@babel/core": "^7.28.5",
-		"@babel/eslint-parser": "^7.28.5",
-		"@eslint/eslintrc": "^3.3.1",
+		"@babel/code-frame": "^7.28.3",
+		"@eslint/eslintrc": "^3.3.5",
 		"@lubien/fixture-beta-package": "^1.0.0-beta.1",
-		"@typescript-eslint/parser": "^8.46.2",
-		"@typescript-eslint/types": "^8.46.2",
-		"ava": "^6.4.1",
-		"c8": "^10.1.3",
+		"@typescript-eslint/parser": "^8.57.2",
+		"@typescript-eslint/types": "^8.57.2",
+		"ava": "^7.0.0",
+		"c8": "^11.0.0",
 		"enquirer": "^2.4.1",
-		"eslint": "^9.38.0",
+		"eslint": "^10.1.0",
 		"eslint-ava-rule-tester": "^5.0.1",
-		"eslint-config-xo": "^0.49.0",
-		"eslint-doc-generator": "^2.3.0",
-		"eslint-plugin-eslint-plugin": "^7.1.0",
-		"eslint-plugin-jsdoc": "^61.1.6",
-		"eslint-plugin-unicorn": "^61.0.2",
-		"eslint-remote-tester": "^4.0.3",
+		"eslint-config-xo": "^0.51.0",
+		"eslint-doc-generator": "^3.3.2",
+		"eslint-plugin-eslint-plugin": "^7.3.2",
+		"eslint-plugin-jsdoc": "^62.8.1",
+		"eslint-plugin-unicorn": "^63.0.0",
+		"eslint-remote-tester": "^4.0.4",
 		"eslint-remote-tester-repositories": "^2.0.2",
-		"espree": "^10.4.0",
-		"listr2": "^9.0.5",
-		"lodash-es": "^4.17.21",
-		"markdownlint-cli": "^0.45.0",
+		"eslint-scope": "^9.1.2",
+		"espree": "^11.2.0",
+		"listr2": "^10.2.1",
+		"markdownlint-cli": "^0.48.0",
 		"nano-spawn": "^2.0.0",
 		"node-style-text": "^2.1.2",
-		"npm-package-json-lint": "^9.0.0",
+		"npm-package-json-lint": "^9.1.0",
 		"npm-run-all2": "^8.0.4",
-		"open-editor": "^5.1.0",
+		"open-editor": "^6.0.0",
 		"outdent": "^0.8.0",
 		"pretty-ms": "^9.3.0",
 		"typescript": "^5.9.3",
-		"vue-eslint-parser": "^10.2.0",
-		"yaml": "^2.8.1"
+		"vue-eslint-parser": "^10.4.0",
+		"yaml": "^2.8.3"
 	},
 	"peerDependencies": {
 		"eslint": ">=9.38.0"

package/readme.md

@@ -65,6 +65,7 @@ export default [
 | [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.                                                                                                                                                          | ✅    |    |    |
+| [consistent-template-literal-escape](docs/rules/consistent-template-literal-escape.md)           | Enforce consistent style for escaping `${` in template literals.                                                                                                                                                  | ✅    | 🔧 |    |
 | [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.                                                                                                                                                                                 | ✅    | 🔧 |    |
 | [error-message](docs/rules/error-message.md)                                                     | Enforce passing a `message` value when creating a built-in error.                                                                                                                                                 | ✅ ☑️ |    |    |
@@ -73,6 +74,7 @@ export default [
 | [explicit-length-check](docs/rules/explicit-length-check.md)                                     | Enforce explicitly comparing the `length` or `size` property of a value.                                                                                                                                          | ✅    | 🔧 | 💡 |
 | [filename-case](docs/rules/filename-case.md)                                                     | Enforce a case style for filenames.                                                                                                                                                                               | ✅    |    |    |
 | [import-style](docs/rules/import-style.md)                                                       | Enforce specific import styles per module.                                                                                                                                                                        | ✅ ☑️ |    |    |
+| [isolated-functions](docs/rules/isolated-functions.md)                                           | Prevent usage of variables from outside the scope of isolated functions.                                                                                                                                          | ✅    |    |    |
 | [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-accessor-recursion](docs/rules/no-accessor-recursion.md)                                     | Disallow recursive access to `this` within getters and setters.                                                                                                                                                   | ✅ ☑️ |    |    |
@@ -119,9 +121,10 @@ export default [
 | [no-unreadable-array-destructuring](docs/rules/no-unreadable-array-destructuring.md)             | Disallow unreadable array destructuring.                                                                                                                                                                          | ✅ ☑️ | 🔧 |    |
 | [no-unreadable-iife](docs/rules/no-unreadable-iife.md)                                           | Disallow unreadable IIFEs.                                                                                                                                                                                        | ✅ ☑️ |    |    |
 | [no-unused-properties](docs/rules/no-unused-properties.md)                                       | Disallow unused object properties.                                                                                                                                                                                |      |    |    |
-| [no-useless-collection-argument](docs/rules/no-useless-collection-argument.md)                   | Disallow useless values or fallbacks in `Set`, `Map`, `WeakSet`, or `WeakMap`.                                                                                                                                    | ✅ ☑️ | 🔧 |    |
+| [no-useless-collection-argument](docs/rules/no-useless-collection-argument.md)                   | Disallow useless values or fallbacks in `Set`, `Map`, `WeakSet`, or `WeakMap`.                                                                                                                                    | ✅ ☑️ | 🔧 | 💡 |
 | [no-useless-error-capture-stack-trace](docs/rules/no-useless-error-capture-stack-trace.md)       | Disallow unnecessary `Error.captureStackTrace(…)`.                                                                                                                                                                | ✅ ☑️ | 🔧 |    |
 | [no-useless-fallback-in-spread](docs/rules/no-useless-fallback-in-spread.md)                     | Disallow useless fallback when spreading in object literals.                                                                                                                                                      | ✅ ☑️ | 🔧 |    |
+| [no-useless-iterator-to-array](docs/rules/no-useless-iterator-to-array.md)                       | Disallow unnecessary `.toArray()` on iterators.                                                                                                                                                                   | ✅ ☑️ | 🔧 | 💡 |
 | [no-useless-length-check](docs/rules/no-useless-length-check.md)                                 | Disallow useless array length check.                                                                                                                                                                              | ✅ ☑️ | 🔧 |    |
 | [no-useless-promise-resolve-reject](docs/rules/no-useless-promise-resolve-reject.md)             | Disallow returning/yielding `Promise.resolve/reject()` in async functions or promise callbacks                                                                                                                    | ✅ ☑️ | 🔧 |    |
 | [no-useless-spread](docs/rules/no-useless-spread.md)                                             | Disallow unnecessary spread.                                                                                                                                                                                      | ✅ ☑️ | 🔧 |    |
@@ -174,6 +177,7 @@ export default [
 | [prefer-response-static-json](docs/rules/prefer-response-static-json.md)                         | Prefer `Response.json()` over `new Response(JSON.stringify())`.                                                                                                                                                   | ✅ ☑️ | 🔧 |    |
 | [prefer-set-has](docs/rules/prefer-set-has.md)                                                   | Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence.                                                                                                                          | ✅ ☑️ | 🔧 | 💡 |
 | [prefer-set-size](docs/rules/prefer-set-size.md)                                                 | Prefer using `Set#size` instead of `Array#length`.                                                                                                                                                                | ✅ ☑️ | 🔧 |    |
+| [prefer-simple-condition-first](docs/rules/prefer-simple-condition-first.md)                     | Prefer simple conditions first in logical expressions.                                                                                                                                                            | ✅ ☑️ | 🔧 | 💡 |
 | [prefer-single-call](docs/rules/prefer-single-call.md)                                           | Enforce combining multiple `Array#push()`, `Element#classList.{add,remove}()`, and `importScripts()` into one call.                                                                                               | ✅ ☑️ | 🔧 | 💡 |
 | [prefer-spread](docs/rules/prefer-spread.md)                                                     | Prefer the spread operator over `Array.from(…)`, `Array#concat(…)`, `Array#{slice,toSpliced}()` and `String#split('')`.                                                                                           | ✅    | 🔧 | 💡 |
 | [prefer-string-raw](docs/rules/prefer-string-raw.md)                                             | Prefer using the `String.raw` tag to avoid escaping `\`.                                                                                                                                                          | ✅ ☑️ | 🔧 |    |
@@ -195,6 +199,7 @@ export default [
 | [require-post-message-target-origin](docs/rules/require-post-message-target-origin.md)           | Enforce using the `targetOrigin` argument with `window.postMessage()`.                                                                                                                                            |      |    | 💡 |
 | [string-content](docs/rules/string-content.md)                                                   | Enforce better string content.                                                                                                                                                                                    |      | 🔧 | 💡 |
 | [switch-case-braces](docs/rules/switch-case-braces.md)                                           | Enforce consistent brace style for `case` clauses.                                                                                                                                                                | ✅    | 🔧 |    |
+| [switch-case-break-position](docs/rules/switch-case-break-position.md)                           | Enforce consistent `break`/`return`/`continue`/`throw` position in `case` clauses.                                                                                                                                | ✅    | 🔧 |    |
 | [template-indent](docs/rules/template-indent.md)                                                 | Fix whitespace-insensitive template indentation.                                                                                                                                                                  | ✅    | 🔧 |    |
 | [text-encoding-identifier-case](docs/rules/text-encoding-identifier-case.md)                     | Enforce consistent case for text encoding identifiers.                                                                                                                                                            | ✅ ☑️ | 🔧 | 💡 |
 | [throw-new-error](docs/rules/throw-new-error.md)                                                 | Require `new` when creating an error.                                                                                                                                                                             | ✅ ☑️ | 🔧 |    |

package/rules/ast/call-or-new-expression.js

@@ -71,11 +71,9 @@ function create(node, options, types) {
 		const maximumArgumentsLength = Number.isFinite(maximumArguments) ? maximumArguments : argumentsLength;
 		if (
 			typeof maximumArgumentsLength === 'number'
-			&& node.arguments.some(
-				(node, index) =>
-					node.type === 'SpreadElement'
-					&& index < maximumArgumentsLength,
-			)
+			&& node.arguments.some((node, index) =>
+				node.type === 'SpreadElement'
+				&& index < maximumArgumentsLength)
 		) {
 			return false;
 		}

package/rules/ast/index.js

@@ -18,6 +18,7 @@ export {default as isArrowFunctionBody} from './is-arrow-function-body.js';
 export {default as isDirective} from './is-directive.js';
 export {default as isEmptyNode} from './is-empty-node.js';
 export {default as isEmptyArrayExpression} from './is-empty-array-expression.js';
+export {default as isEmptyObjectExpression} from './is-empty-object-expression.js';
 export {default as isExpressionStatement} from './is-expression-statement.js';
 export {default as isFunction} from './is-function.js';
 export {default as isMemberExpression} from './is-member-expression.js';

package/rules/ast/is-empty-object-expression.js

@@ -0,0 +1,5 @@
+const isEmptyArrayExpression = node =>
+	node.type === 'ObjectExpression'
+	&& node.properties.length === 0;
+
+export default isEmptyArrayExpression;

package/rules/ast/literal.js

@@ -3,10 +3,6 @@ export function isLiteral(node, value) {
 		return false;
 	}
 
-	if (value === null) {
-		return node.raw === 'null';
-	}
-
 	return node.value === value;
 }
 
@@ -16,8 +12,7 @@ export const isNumericLiteral = node => node.type === 'Literal' && typeof node.v
 
 export const isRegexLiteral = node => node.type === 'Literal' && Boolean(node.regex);
 
-// eslint-disable-next-line unicorn/no-null
-export const isNullLiteral = node => isLiteral(node, null);
+export const isNullLiteral = node => node?.type === 'Literal' && node.raw === 'null';
 
 export const isBigIntLiteral = node => node.type === 'Literal' && Boolean(node.bigint);
 

package/rules/better-regex.js

@@ -10,9 +10,17 @@ const messages = {
 	[MESSAGE_ID_PARSE_ERROR]: 'Problem parsing {{original}}: {{error}}',
 };
 
+// `regexp-tree` can optimize `/|/` into `//`, which is not valid JavaScript syntax.
+// Normalize to an explicit empty alternative so the autofix always stays parseable.
+const normalizeOptimizedRegexLiteral = optimizedRegexLiteral => (
+	optimizedRegexLiteral.startsWith('//')
+		? `/(?:)/${optimizedRegexLiteral.slice(2)}`
+		: optimizedRegexLiteral
+);
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const {sortCharacterClasses} = context.options[0] || {};
+	const {sortCharacterClasses} = context.options[0];
 
 	const ignoreList = [];
 
@@ -20,99 +28,99 @@ const create = context => {
 		ignoreList.push('charClassClassrangesMerge');
 	}
 
-	return {
-		Literal(node) {
-			if (!isRegexLiteral(node)) {
-				return;
-			}
-
-			const {raw: original, regex} = node;
-			// Regular Expressions with `u` and `v` flag are not well handled by `regexp-tree`
-			// https://github.com/DmitrySoshnikov/regexp-tree/issues/162
-			if (regex.flags.includes('u') || regex.flags.includes('v')) {
-				return;
-			}
-
-			let optimized = original;
-
-			try {
-				optimized = regexpTree.optimize(original, undefined, {blacklist: ignoreList}).toString();
-			} catch (error) {
-				return {
-					node,
-					messageId: MESSAGE_ID_PARSE_ERROR,
-					data: {
-						original,
-						error: error.message,
-					},
-				};
-			}
-
-			if (original === optimized) {
-				return;
-			}
-
-			const problem = {
+	context.on('Literal', node => {
+		if (!isRegexLiteral(node)) {
+			return;
+		}
+
+		const {raw: original, regex} = node;
+		// Regular Expressions with `u` and `v` flag are not well handled by `regexp-tree`
+		// https://github.com/DmitrySoshnikov/regexp-tree/issues/162
+		if (regex.flags.includes('u') || regex.flags.includes('v')) {
+			return;
+		}
+
+		let optimized = original;
+
+		try {
+			optimized = regexpTree.optimize(original, undefined, {blacklist: ignoreList}).toString();
+			optimized = normalizeOptimizedRegexLiteral(optimized);
+		} catch (error) {
+			return {
 				node,
-				messageId: MESSAGE_ID,
+				messageId: MESSAGE_ID_PARSE_ERROR,
 				data: {
 					original,
-					optimized,
+					error: error.message,
 				},
 			};
-
-			if (
-				node.parent.type === 'MemberExpression'
-				&& node.parent.object === node
-				&& !node.parent.optional
-				&& !node.parent.computed
-				&& node.parent.property.type === 'Identifier'
-				&& (
-					node.parent.property.name === 'toString'
-					|| node.parent.property.name === 'source'
-				)
-			) {
-				return problem;
-			}
-
-			return Object.assign(problem, {
-				fix: fixer => fixer.replaceText(node, optimized),
-			});
-		},
-		NewExpression(node) {
-			if (!isNewExpression(node, {name: 'RegExp', minimumArguments: 1})) {
-				return;
-			}
-
-			const [patternNode, flagsNode] = node.arguments;
-
-			if (!isStringLiteral(patternNode)) {
-				return;
-			}
-
-			const oldPattern = patternNode.value;
-			const flags = isStringLiteral(flagsNode)
-				? flagsNode.value
-				: '';
-
-			const newPattern = cleanRegexp(oldPattern, flags);
-
-			if (oldPattern !== newPattern) {
-				return {
-					node,
-					messageId: MESSAGE_ID,
-					data: {
-						original: oldPattern,
-						optimized: newPattern,
-					},
-					fix: fixer => fixer.replaceText(
-						patternNode,
-						escapeString(newPattern, patternNode.raw.charAt(0)),
-					),
-				};
-			}
-		},
-	};
+		}
+
+		if (original === optimized) {
+			return;
+		}
+
+		const problem = {
+			node,
+			messageId: MESSAGE_ID,
+			data: {
+				original,
+				optimized,
+			},
+		};
+
+		if (
+			node.parent.type === 'MemberExpression'
+			&& node.parent.object === node
+			&& !node.parent.optional
+			&& !node.parent.computed
+			&& node.parent.property.type === 'Identifier'
+			&& (
+				node.parent.property.name === 'toString'
+				|| node.parent.property.name === 'source'
+			)
+		) {
+			return problem;
+		}
+
+		return Object.assign(problem, {
+			fix: fixer => fixer.replaceText(node, optimized),
+		});
+	});
+
+	context.on('NewExpression', node => {
+		if (!isNewExpression(node, {name: 'RegExp', minimumArguments: 1})) {
+			return;
+		}
+
+		const [patternNode, flagsNode] = node.arguments;
+
+		if (!isStringLiteral(patternNode)) {
+			return;
+		}
+
+		const oldPattern = patternNode.value;
+		const flags = isStringLiteral(flagsNode)
+			? flagsNode.value
+			: '';
+
+		const newPattern = cleanRegexp(oldPattern, flags);
+
+		if (oldPattern !== newPattern) {
+			return {
+				node,
+				messageId: MESSAGE_ID,
+				data: {
+					original: oldPattern,
+					optimized: newPattern,
+				},
+				fix: fixer => fixer.replaceText(
+					patternNode,
+					escapeString(newPattern, patternNode.raw.charAt(0)),
+				),
+			};
+		}
+	});
 };
 
 const schema = [
@@ -122,6 +130,7 @@ const schema = [
 		properties: {
 			sortCharacterClasses: {
 				type: 'boolean',
+				description: 'Whether to sort character classes.',
 			},
 		},
 	},