eslint-plugin-unicorn 62.0.0 → 63.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'],
@@ -68,7 +67,7 @@ const unicorn = {
 		version: packageJson.version,
 	},
 	rules: {
-		...createRules(rules),
+		...rules,
 		...deprecatedRules,
 	},
 };
@@ -83,9 +82,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": "63.0.0",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -58,12 +58,10 @@
 	"dependencies": {
 		"@babel/helper-validator-identifier": "^7.28.5",
 		"@eslint-community/eslint-utils": "^4.9.0",
-		"@eslint/plugin-kit": "^0.4.0",
 		"change-case": "^5.4.4",
 		"ci-info": "^4.3.1",
 		"clean-regexp": "^1.0.0",
 		"core-js-compat": "^3.46.0",
-		"esquery": "^1.6.0",
 		"find-up-simple": "^1.0.1",
 		"globals": "^16.4.0",
 		"indent-string": "^5.0.0",
@@ -81,12 +79,12 @@
 		"@babel/eslint-parser": "^7.28.5",
 		"@eslint/eslintrc": "^3.3.1",
 		"@lubien/fixture-beta-package": "^1.0.0-beta.1",
-		"@typescript-eslint/parser": "^8.46.2",
-		"@typescript-eslint/types": "^8.46.2",
+		"@typescript-eslint/parser": "^8.53.1",
+		"@typescript-eslint/types": "^8.53.1",
 		"ava": "^6.4.1",
 		"c8": "^10.1.3",
 		"enquirer": "^2.4.1",
-		"eslint": "^9.38.0",
+		"eslint": "^10.0.0",
 		"eslint-ava-rule-tester": "^5.0.1",
 		"eslint-config-xo": "^0.49.0",
 		"eslint-doc-generator": "^2.3.0",
@@ -95,15 +93,15 @@
 		"eslint-plugin-unicorn": "^61.0.2",
 		"eslint-remote-tester": "^4.0.3",
 		"eslint-remote-tester-repositories": "^2.0.2",
+		"eslint-scope": "^9.0.0",
 		"espree": "^10.4.0",
 		"listr2": "^9.0.5",
-		"lodash-es": "^4.17.21",
 		"markdownlint-cli": "^0.45.0",
 		"nano-spawn": "^2.0.0",
 		"node-style-text": "^2.1.2",
 		"npm-package-json-lint": "^9.0.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",

package/readme.md

@@ -73,6 +73,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,7 +120,7 @@ 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-length-check](docs/rules/no-useless-length-check.md)                                 | Disallow useless array length check.                                                                                                                                                                              | ✅ ☑️ | 🔧 |    |

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/better-regex.js

@@ -12,7 +12,7 @@ const messages = {
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const {sortCharacterClasses} = context.options[0] || {};
+	const {sortCharacterClasses} = context.options[0];
 
 	const ignoreList = [];
 
@@ -20,99 +20,98 @@ 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();
+		} 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 = [

package/rules/catch-error-name.js

@@ -32,11 +32,7 @@ const isPromiseCatchParameter = node =>
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const options = {
-		name: 'error',
-		ignore: [],
-		...context.options[0],
-	};
+	const options = context.options[0];
 	const {name: expectedName} = options;
 	const ignore = options.ignore.map(
 		pattern => isRegExp(pattern) ? pattern : new RegExp(pattern, 'u'),
@@ -47,60 +43,58 @@ const create = context => {
 		|| name.endsWith(expectedName)
 		|| name.endsWith(upperFirst(expectedName));
 
-	return {
-		Identifier(node) {
-			if (
-				!(node.parent.type === 'CatchClause' && node.parent.param === node)
-				&& !isPromiseCatchParameter(node)
-			) {
-				return;
-			}
-
-			const originalName = node.name;
-
-			if (
-				isNameAllowed(originalName)
-				|| isNameAllowed(originalName.replaceAll(/_+$/g, ''))
-			) {
-				return;
-			}
-
-			const scope = context.sourceCode.getScope(node);
-			const variable = findVariable(scope, node);
-
-			// This was reported https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1075#issuecomment-768072967
-			// But can't reproduce, just ignore this case
-			/* c8 ignore next 3 */
-			if (!variable) {
-				return;
-			}
-
-			if (originalName === '_' && variable.references.length === 0) {
-				return;
-			}
-
-			const scopes = [
-				variable.scope,
-				...variable.references.map(({from}) => from),
-			];
-			const fixedName = getAvailableVariableName(expectedName, scopes);
-
-			const problem = {
-				node,
-				messageId: MESSAGE_ID,
-				data: {
-					originalName,
-					fixedName: fixedName || expectedName,
-				},
-			};
-
-			if (fixedName) {
-				problem.fix = fixer => renameVariable(variable, fixedName, context, fixer);
-			}
-
-			return problem;
-		},
-	};
+	context.on('Identifier', node => {
+		if (
+			!(node.parent.type === 'CatchClause' && node.parent.param === node)
+			&& !isPromiseCatchParameter(node)
+		) {
+			return;
+		}
+
+		const originalName = node.name;
+
+		if (
+			isNameAllowed(originalName)
+			|| isNameAllowed(originalName.replaceAll(/_+$/g, ''))
+		) {
+			return;
+		}
+
+		const scope = context.sourceCode.getScope(node);
+		const variable = findVariable(scope, node);
+
+		// This was reported https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1075#issuecomment-768072967
+		// But can't reproduce, just ignore this case
+		/* c8 ignore next 3 */
+		if (!variable) {
+			return;
+		}
+
+		if (originalName === '_' && variable.references.length === 0) {
+			return;
+		}
+
+		const scopes = [
+			variable.scope,
+			...variable.references.map(({from}) => from),
+		];
+		const fixedName = getAvailableVariableName(expectedName, scopes);
+
+		const problem = {
+			node,
+			messageId: MESSAGE_ID,
+			data: {
+				originalName,
+				fixedName: fixedName || expectedName,
+			},
+		};
+
+		if (fixedName) {
+			problem.fix = fixer => renameVariable(variable, fixedName, context, fixer);
+		}
+
+		return problem;
+	});
 };
 
 const schema = [
@@ -130,7 +124,7 @@ const config = {
 		},
 		fixable: 'code',
 		schema,
-		defaultOptions: [{}],
+		defaultOptions: [{name: 'error', ignore: []}],
 		messages,
 	},
 };

package/rules/consistent-assert.js

@@ -22,20 +22,22 @@ const isAssertFunction = (specifier, moduleName) =>
 	// `import {default as assert} from 'node:assert/strict';`
 	|| (
 		specifier.type === 'ImportSpecifier'
+		&& specifier.imported.type === 'Identifier'
 		&& specifier.imported.name === 'default'
 	)
 	// `import {strict as assert} from 'node:assert';`
 	|| (
 		moduleName === 'assert'
 		&& specifier.type === 'ImportSpecifier'
+		&& specifier.imported.type === 'Identifier'
 		&& specifier.imported.name === 'strict'
 	);
 
 const NODE_PROTOCOL = 'node:';
 
 /** @type {import('eslint').Rule.RuleModule['create']} */
-const create = context => ({
-	* ImportDeclaration(importDeclaration) {
+const create = context => {
+	context.on('ImportDeclaration', function * (importDeclaration) {
 		if (!isValueImport(importDeclaration)) {
 			return;
 		}
@@ -78,8 +80,8 @@ const create = context => ({
 				};
 			}
 		}
-	},
-});
+	});
+};
 
 /** @type {import('eslint').Rule.RuleModule} */
 const config = {

package/rules/consistent-date-clone.js

@@ -7,8 +7,8 @@ const messages = {
 };
 
 /** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	NewExpression(newExpression) {
+const create = context => {
+	context.on('NewExpression', newExpression => {
 		if (!isNewExpression(newExpression, {name: 'Date', argumentsLength: 1})) {
 			return;
 		}
@@ -34,8 +34,8 @@ const create = context => ({
 			messageId: MESSAGE_ID_ERROR,
 			fix: fixer => removeMethodCall(fixer, callExpression, context),
 		};
-	},
-});
+	});
+};
 
 /** @type {import('eslint').Rule.RuleModule} */
 const config = {