eslint-plugin-unicorn 64.0.0 → 65.0.0

package/rules/explicit-length-check.js

@@ -6,6 +6,7 @@ import {
 	isBooleanExpression,
 	isControlFlowTest,
 	getBooleanAncestor,
+	isSameReference,
 } from './utils/index.js';
 import {fixSpaceAroundKeyword} from './fix/index.js';
 import {isLiteral, isMemberExpression} from './ast/index.js';
@@ -48,8 +49,107 @@ const zeroStyle = {
 	test: node => isCompareRight(node, '===', 0),
 };
 
-function getLengthCheckNode(node) {
+const shapeProperties = new Set(['depth', 'height', 'width']);
+
+function isLengthOrSizeMemberExpression(node) {
+	return isMemberExpression(node, {
+		properties: ['length', 'size'],
+		optional: false,
+	});
+}
+
+function isTypeScriptExpression(node) {
+	return node?.type === 'TSAsExpression'
+		|| node?.type === 'TSSatisfiesExpression'
+		|| node?.type === 'TSTypeAssertion'
+		|| node?.type === 'TSNonNullExpression';
+}
+
+function unwrapTypeScriptExpression(node) {
+	if (isTypeScriptExpression(node)) {
+		return unwrapTypeScriptExpression(node.expression);
+	}
+
+	return node;
+}
+
+function getLengthCheckParent(node, allowTypeScriptExpression) {
 	node = node.parent;
+	if (allowTypeScriptExpression) {
+		while (isTypeScriptExpression(node)) {
+			node = node.parent;
+		}
+	}
+
+	return node;
+}
+
+function getLogicalExpressionRoot(node) {
+	while (
+		isLogicalExpression(node.parent)
+		&& node.parent.operator === '&&'
+	) {
+		node = node.parent;
+	}
+
+	return node;
+}
+
+function getLogicalExpressionOperands(node) {
+	return [node.left, node.right].flatMap(child =>
+		child.type === 'LogicalExpression' && child.operator === node.operator
+			? getLogicalExpressionOperands(child)
+			: [child]);
+}
+
+function hasSameObjectShapePropertyCheck({node, lengthNode}) {
+	const root = getLogicalExpressionRoot(node);
+	if (
+		root.type !== 'LogicalExpression'
+		|| root.operator !== '&&'
+	) {
+		return false;
+	}
+
+	return getLogicalExpressionOperands(root).some(operand =>
+		operand !== node
+		&& isMemberExpression(operand, {computed: false, optional: false})
+		&& operand.property.type === 'Identifier'
+		&& shapeProperties.has(operand.property.name)
+		&& isSameReference(operand.object, lengthNode.object));
+}
+
+function getLengthCheckMemberExpression(node) {
+	if (node.type === 'UnaryExpression' && node.operator === '!') {
+		return getLengthCheckMemberExpression(node.argument);
+	}
+
+	if (
+		node.type === 'CallExpression'
+		&& node.callee.type === 'Identifier'
+		&& node.callee.name === 'Boolean'
+		&& node.arguments.length === 1
+	) {
+		return getLengthCheckMemberExpression(node.arguments[0]);
+	}
+
+	if (node.type !== 'BinaryExpression') {
+		return;
+	}
+
+	const left = unwrapTypeScriptExpression(node.left);
+	if (isLengthOrSizeMemberExpression(left)) {
+		return left;
+	}
+
+	const right = unwrapTypeScriptExpression(node.right);
+	if (isLengthOrSizeMemberExpression(right)) {
+		return right;
+	}
+}
+
+function getLengthCheckNode(node, {allowTypeScriptExpression = false} = {}) {
+	node = getLengthCheckParent(node, allowTypeScriptExpression);
 
 	// Zero length check
 	if (
@@ -81,7 +181,7 @@ function getLengthCheckNode(node) {
 		|| isCompareRight(node, '>=', 1)
 		// `0 !== foo.length`
 		|| isCompareLeft(node, '!==', 0)
-		// `0 !== foo.length`
+		// `0 != foo.length`
 		|| isCompareLeft(node, '!=', 0)
 		// `0 < foo.length`
 		|| isCompareLeft(node, '<', 0)
@@ -94,6 +194,35 @@ function getLengthCheckNode(node) {
 	return {};
 }
 
+function isSameLengthNonZeroCheck(node, lengthNode) {
+	const comparisonLengthNode = getLengthCheckMemberExpression(node);
+	if (!comparisonLengthNode || !isSameReference(comparisonLengthNode, lengthNode)) {
+		return false;
+	}
+
+	const {isZeroLengthCheck, node: lengthCheckNode} = getLengthCheckNode(comparisonLengthNode, {allowTypeScriptExpression: true});
+	if (!lengthCheckNode) {
+		return false;
+	}
+
+	const {isNegative, node: ancestor} = getBooleanAncestor(lengthCheckNode);
+	return ancestor === node && isNegative === isZeroLengthCheck;
+}
+
+function isLengthGuardedByNonZeroCheck(lengthNode) {
+	const root = getLogicalExpressionRoot(lengthNode);
+	if (
+		root.type !== 'LogicalExpression'
+		|| root.operator !== '&&'
+	) {
+		return false;
+	}
+
+	return getLogicalExpressionOperands(root).some(operand =>
+		operand !== lengthNode
+		&& isSameLengthNonZeroCheck(operand, lengthNode));
+}
+
 function create(context) {
 	const options = context.options[0];
 	const nonZeroStyle = nonZeroStyles.get(options['non-zero']);
@@ -141,10 +270,7 @@ function create(context) {
 
 	context.on('MemberExpression', memberExpression => {
 		if (
-			!isMemberExpression(memberExpression, {
-				properties: ['length', 'size'],
-				optional: false,
-			})
+			!isLengthOrSizeMemberExpression(memberExpression)
 			|| memberExpression.object.type === 'ThisExpression'
 		) {
 			return;
@@ -179,6 +305,13 @@ function create(context) {
 		}
 
 		if (node) {
+			if (
+				(node === lengthNode && isLengthGuardedByNonZeroCheck(lengthNode))
+				|| hasSameObjectShapePropertyCheck({node, lengthNode})
+			) {
+				return;
+			}
+
 			const isUnsafeNegationInBinaryExpression = node.type === 'UnaryExpression'
 				&& node.operator === '!'
 				&& node.parent.type === 'BinaryExpression'

package/rules/filename-case.js

@@ -9,9 +9,11 @@ import {
 import cartesianProductSamples from './utils/cartesian-product-samples.js';
 
 const MESSAGE_ID = 'filename-case';
+const MESSAGE_ID_DIRECTORY = 'directory-case';
 const MESSAGE_ID_EXTENSION = 'filename-extension';
 const messages = {
 	[MESSAGE_ID]: 'Filename is not in {{chosenCases}}. Rename it to {{renamedFilenames}}.',
+	[MESSAGE_ID_DIRECTORY]: 'Directory name `{{directory}}` is not in {{chosenCases}}. Rename it to {{renamedDirectories}}.',
 	[MESSAGE_ID_EXTENSION]: 'File extension `{{extension}}` is not in lowercase. Rename it to `{{filename}}`.',
 };
 
@@ -59,13 +61,13 @@ function getChosenCases(options) {
 	return ['kebabCase'];
 }
 
-function validateFilename(words, caseFunctions) {
+function validateName(words, caseFunctions) {
 	return words
 		.filter(({ignored}) => !ignored)
 		.every(({word}) => caseFunctions.some(caseFunction => caseFunction(word) === word));
 }
 
-function fixFilename(words, caseFunctions, {leading, trailing}) {
+function fixName(words, caseFunctions, {leading, trailing}) {
 	const replacements = words
 		.map(({word, ignored}) => ignored ? [word] : caseFunctions.map(caseFunction => caseFunction(word)));
 
@@ -99,10 +101,29 @@ function getFilenameParts(filenameWithExtension, {multipleFileExtensions}) {
 	return parts;
 }
 
+function isInsideCwd(relativePath) {
+	return relativePath !== ''
+		&& relativePath !== '..'
+		&& !relativePath.startsWith(`..${path.sep}`)
+		&& !path.isAbsolute(relativePath);
+}
+
+function getPathSegments(filenameWithExtension, cwd) {
+	const relativePath = path.relative(cwd, path.resolve(cwd, filenameWithExtension));
+
+	if (!isInsideCwd(relativePath)) {
+		return [path.basename(filenameWithExtension)];
+	}
+
+	return relativePath
+		.split(path.sep)
+		.filter(segment => segment !== '.');
+}
+
 const leadingUnderscoresRegex = /^(?<leading>_+)(?<tailing>.*)$/;
-function splitFilename(filename) {
-	const result = leadingUnderscoresRegex.exec(filename) || {groups: {}};
-	const {leading = '', tailing = filename} = result.groups;
+function splitName(name) {
+	const result = leadingUnderscoresRegex.exec(name) || {groups: {}};
+	const {leading = '', tailing = name} = result.groups;
 
 	const words = [];
 
@@ -135,6 +156,33 @@ Turns `[a, b, c]` into `a, b, or c`.
 */
 const englishishJoinWords = words => new Intl.ListFormat('en-US', {type: 'disjunction'}).format(words);
 
+function getCaseNames(chosenCases) {
+	return englishishJoinWords(chosenCases.map(x => cases[x].name));
+}
+
+function getInvalidDirectoryReport(directory, chosenCases, chosenCasesFunctions) {
+	const {leading, words} = splitName(directory);
+
+	if (directory.startsWith('$') || validateName(words, chosenCasesFunctions)) {
+		return;
+	}
+
+	const renamedDirectories = fixName(words, chosenCasesFunctions, {
+		leading,
+		trailing: '',
+	});
+
+	return {
+		loc: {column: 0, line: 1},
+		messageId: MESSAGE_ID_DIRECTORY,
+		data: {
+			directory,
+			chosenCases: getCaseNames(chosenCases),
+			renamedDirectories: englishishJoinWords(renamedDirectories.map(x => `\`${x}\``)),
+		},
+	};
+}
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const options = context.options[0] || {};
@@ -147,6 +195,7 @@ const create = context => {
 		return new RegExp(item, 'u');
 	});
 	const multipleFileExtensions = options.multipleFileExtensions !== false;
+	const checkDirectories = options.checkDirectories !== false;
 	const chosenCasesFunctions = chosenCases.map(case_ => cases[case_].fn);
 	const filenameWithExtension = context.physicalFilename;
 
@@ -155,19 +204,35 @@ const create = context => {
 	}
 
 	context.on('Program', () => {
+		const pathSegments = getPathSegments(filenameWithExtension, context.cwd);
+		const basenameWithExtension = pathSegments.at(-1);
 		const {
 			basename,
 			filename,
 			middle,
 			extension,
-		} = getFilenameParts(filenameWithExtension, {multipleFileExtensions});
+		} = getFilenameParts(basenameWithExtension, {multipleFileExtensions});
+
+		if (pathSegments.some(segment => ignore.some(regexp => regexp.test(segment)))) {
+			return;
+		}
 
-		if (ignoredByDefault.has(basename) || ignore.some(regexp => regexp.test(basename))) {
+		if (checkDirectories) {
+			for (const directory of pathSegments.slice(0, -1)) {
+				const report = getInvalidDirectoryReport(directory, chosenCases, chosenCasesFunctions);
+
+				if (report) {
+					return report;
+				}
+			}
+		}
+
+		if (ignoredByDefault.has(basename)) {
 			return;
 		}
 
-		const {leading, words} = splitFilename(filename);
-		const isValid = validateFilename(words, chosenCasesFunctions);
+		const {leading, words} = splitName(filename);
+		const isValid = filename.startsWith('$') || validateName(words, chosenCasesFunctions);
 
 		if (isValid) {
 			if (!isLowerCase(extension)) {
@@ -181,7 +246,7 @@ const create = context => {
 			return;
 		}
 
-		const renamedFilenames = fixFilename(words, chosenCasesFunctions, {
+		const renamedFilenames = fixName(words, chosenCasesFunctions, {
 			leading,
 			trailing: middle + extension.toLowerCase(),
 		});
@@ -192,7 +257,7 @@ const create = context => {
 			loc: {column: 0, line: 1},
 			messageId: MESSAGE_ID,
 			data: {
-				chosenCases: englishishJoinWords(chosenCases.map(x => cases[x].name)),
+				chosenCases: getCaseNames(chosenCases),
 				renamedFilenames: englishishJoinWords(renamedFilenames.map(x => `\`${x}\``)),
 			},
 		};
@@ -201,7 +266,8 @@ const create = context => {
 
 const schema = [
 	{
-		oneOf: [
+		description: 'The rule options.',
+		anyOf: [
 			{
 				properties: {
 					case: {
@@ -211,17 +277,21 @@ const schema = [
 							'kebabCase',
 							'pascalCase',
 						],
-						description: 'The filename case style.',
+						description: 'The filename and directory name case style.',
 					},
 					ignore: {
 						type: 'array',
 						uniqueItems: true,
-						description: 'Patterns to ignore.',
+						description: 'Path segment patterns to ignore.',
 					},
 					multipleFileExtensions: {
 						type: 'boolean',
 						description: 'Whether to treat additional, dot-separated parts of a filename as file extensions.',
 					},
+					checkDirectories: {
+						type: 'boolean',
+						description: 'Whether to check directory names.',
+					},
 				},
 				additionalProperties: false,
 			},
@@ -231,33 +301,37 @@ const schema = [
 						properties: {
 							camelCase: {
 								type: 'boolean',
-								description: 'Whether to allow camelCase filenames.',
+								description: 'Whether to allow camelCase filenames and directory names.',
 							},
 							snakeCase: {
 								type: 'boolean',
-								description: 'Whether to allow snake_case filenames.',
+								description: 'Whether to allow snake_case filenames and directory names.',
 							},
 							kebabCase: {
 								type: 'boolean',
-								description: 'Whether to allow kebab-case filenames.',
+								description: 'Whether to allow kebab-case filenames and directory names.',
 							},
 							pascalCase: {
 								type: 'boolean',
-								description: 'Whether to allow PascalCase filenames.',
+								description: 'Whether to allow PascalCase filenames and directory names.',
 							},
 						},
 						additionalProperties: false,
-						description: 'The allowed filename case styles.',
+						description: 'The allowed filename and directory name case styles.',
 					},
 					ignore: {
 						type: 'array',
 						uniqueItems: true,
-						description: 'Patterns to ignore.',
+						description: 'Path segment patterns to ignore.',
 					},
 					multipleFileExtensions: {
 						type: 'boolean',
 						description: 'Whether to treat additional, dot-separated parts of a filename as file extensions.',
 					},
+					checkDirectories: {
+						type: 'boolean',
+						description: 'Whether to check directory names.',
+					},
 				},
 				additionalProperties: false,
 			},
@@ -271,7 +345,7 @@ const config = {
 	meta: {
 		type: 'suggestion',
 		docs: {
-			description: 'Enforce a case style for filenames.',
+			description: 'Enforce a case style for filenames and directory names.',
 			recommended: true,
 		},
 		schema,

package/rules/import-style.js

@@ -2,8 +2,10 @@ import {getStringIfConstant} from '@eslint-community/eslint-utils';
 import {isCallExpression} from './ast/index.js';
 
 const MESSAGE_ID = 'importStyle';
+const MESSAGE_ID_BANNED = 'importStyleBanned';
 const messages = {
 	[MESSAGE_ID]: 'Use {{allowedStyles}} import for module `{{moduleName}}`.',
+	[MESSAGE_ID_BANNED]: 'All import styles are disabled for module `{{moduleName}}`. Use the `no-restricted-imports` rule to disallow a module.',
 };
 
 const getActualImportDeclarationStyles = importDeclaration => {
@@ -144,6 +146,12 @@ const create = context => {
 			.map(name => [name, styles[name] === false ? {} : {...defaultStyles[name], ...styles[name]}]))
 		: styles;
 
+	const bannedModules = new Set(
+		Object.entries(styles)
+			.filter(([, moduleStyles]) => ['unassigned', 'default', 'namespace', 'named'].every(key => moduleStyles[key] === false))
+			.map(([name]) => name),
+	);
+
 	styles = new Map(Object.entries(styles).map(([moduleName, styles]) =>
 		[moduleName, new Set(Object.entries(styles).filter(([, isAllowed]) => isAllowed).map(([style]) => style))]));
 
@@ -151,7 +159,19 @@ const create = context => {
 
 	// eslint-disable-next-line max-params
 	const report = (node, moduleName, actualImportStyles, allowedImportStyles, isRequire = false) => {
-		if (!allowedImportStyles || allowedImportStyles.size === 0) {
+		if (!allowedImportStyles) {
+			return;
+		}
+
+		if (allowedImportStyles.size === 0) {
+			if (bannedModules.has(moduleName)) {
+				context.report({
+					node,
+					messageId: MESSAGE_ID_BANNED,
+					data: {moduleName},
+				});
+			}
+
 			return;
 		}
 

package/rules/index.js

@@ -1,15 +1,18 @@
 // Generated file, DO NOT edit
 
-export {default as 'better-regex'} from './better-regex.js';
+export {default as 'better-dom-traversing'} from './better-dom-traversing.js';
 export {default as 'catch-error-name'} from './catch-error-name.js';
 export {default as 'consistent-assert'} from './consistent-assert.js';
+export {default as 'consistent-compound-words'} from './consistent-compound-words.js';
 export {default as 'consistent-date-clone'} from './consistent-date-clone.js';
 export {default as 'consistent-destructuring'} from './consistent-destructuring.js';
 export {default as 'consistent-empty-array-spread'} from './consistent-empty-array-spread.js';
 export {default as 'consistent-existence-index-check'} from './consistent-existence-index-check.js';
 export {default as 'consistent-function-scoping'} from './consistent-function-scoping.js';
+export {default as 'consistent-json-file-read'} from './consistent-json-file-read.js';
 export {default as 'consistent-template-literal-escape'} from './consistent-template-literal-escape.js';
 export {default as 'custom-error-definition'} from './custom-error-definition.js';
+export {default as 'dom-node-dataset'} from './dom-node-dataset.js';
 export {default as 'empty-brace-spaces'} from './empty-brace-spaces.js';
 export {default as 'error-message'} from './error-message.js';
 export {default as 'escape-case'} from './escape-case.js';
@@ -23,25 +26,36 @@ export {default as 'no-abusive-eslint-disable'} from './no-abusive-eslint-disabl
 export {default as 'no-accessor-recursion'} from './no-accessor-recursion.js';
 export {default as 'no-anonymous-default-export'} from './no-anonymous-default-export.js';
 export {default as 'no-array-callback-reference'} from './no-array-callback-reference.js';
+export {default as 'no-array-fill-with-reference-type'} from './no-array-fill-with-reference-type.js';
 export {default as 'no-array-for-each'} from './no-array-for-each.js';
+export {default as 'no-array-from-fill'} from './no-array-from-fill.js';
 export {default as 'no-array-method-this-argument'} from './no-array-method-this-argument.js';
 export {default as 'no-array-reduce'} from './no-array-reduce.js';
 export {default as 'no-array-reverse'} from './no-array-reverse.js';
 export {default as 'no-array-sort'} from './no-array-sort.js';
 export {default as 'no-await-expression-member'} from './no-await-expression-member.js';
 export {default as 'no-await-in-promise-methods'} from './no-await-in-promise-methods.js';
+export {default as 'no-blob-to-file'} from './no-blob-to-file.js';
+export {default as 'no-canvas-to-image'} from './no-canvas-to-image.js';
+export {default as 'no-confusing-array-splice'} from './no-confusing-array-splice.js';
 export {default as 'no-console-spaces'} from './no-console-spaces.js';
 export {default as 'no-document-cookie'} from './no-document-cookie.js';
+export {default as 'no-duplicate-set-values'} from './no-duplicate-set-values.js';
 export {default as 'no-empty-file'} from './no-empty-file.js';
+export {default as 'no-exports-in-scripts'} from './no-exports-in-scripts.js';
 export {default as 'no-for-loop'} from './no-for-loop.js';
 export {default as 'no-hex-escape'} from './no-hex-escape.js';
 export {default as 'no-immediate-mutation'} from './no-immediate-mutation.js';
+export {default as 'no-incorrect-query-selector'} from './no-incorrect-query-selector.js';
 export {default as 'no-instanceof-builtins'} from './no-instanceof-builtins.js';
 export {default as 'no-invalid-fetch-options'} from './no-invalid-fetch-options.js';
+export {default as 'no-invalid-file-input-accept'} from './no-invalid-file-input-accept.js';
 export {default as 'no-invalid-remove-event-listener'} from './no-invalid-remove-event-listener.js';
 export {default as 'no-keyword-prefix'} from './no-keyword-prefix.js';
+export {default as 'no-late-current-target-access'} from './no-late-current-target-access.js';
 export {default as 'no-lonely-if'} from './no-lonely-if.js';
 export {default as 'no-magic-array-flat-depth'} from './no-magic-array-flat-depth.js';
+export {default as 'no-manually-wrapped-comments'} from './no-manually-wrapped-comments.js';
 export {default as 'no-named-default'} from './no-named-default.js';
 export {default as 'no-negated-condition'} from './no-negated-condition.js';
 export {default as 'no-negation-in-equality-check'} from './no-negation-in-equality-check.js';
@@ -55,14 +69,17 @@ export {default as 'no-single-promise-in-promise-methods'} from './no-single-pro
 export {default as 'no-static-only-class'} from './no-static-only-class.js';
 export {default as 'no-thenable'} from './no-thenable.js';
 export {default as 'no-this-assignment'} from './no-this-assignment.js';
+export {default as 'no-this-outside-of-class'} from './no-this-outside-of-class.js';
 export {default as 'no-typeof-undefined'} from './no-typeof-undefined.js';
 export {default as 'no-unnecessary-array-flat-depth'} from './no-unnecessary-array-flat-depth.js';
 export {default as 'no-unnecessary-array-splice-count'} from './no-unnecessary-array-splice-count.js';
 export {default as 'no-unnecessary-await'} from './no-unnecessary-await.js';
+export {default as 'no-unnecessary-nested-ternary'} from './no-unnecessary-nested-ternary.js';
 export {default as 'no-unnecessary-polyfills'} from './no-unnecessary-polyfills.js';
 export {default as 'no-unnecessary-slice-end'} from './no-unnecessary-slice-end.js';
 export {default as 'no-unreadable-array-destructuring'} from './no-unreadable-array-destructuring.js';
 export {default as 'no-unreadable-iife'} from './no-unreadable-iife.js';
+export {default as 'no-unused-array-method-return'} from './no-unused-array-method-return.js';
 export {default as 'no-unused-properties'} from './no-unused-properties.js';
 export {default as 'no-useless-collection-argument'} from './no-useless-collection-argument.js';
 export {default as 'no-useless-error-capture-stack-trace'} from './no-useless-error-capture-stack-trace.js';
@@ -81,6 +98,7 @@ export {default as 'prefer-array-find'} from './prefer-array-find.js';
 export {default as 'prefer-array-flat-map'} from './prefer-array-flat-map.js';
 export {default as 'prefer-array-flat'} from './prefer-array-flat.js';
 export {default as 'prefer-array-index-of'} from './prefer-array-index-of.js';
+export {default as 'prefer-array-last-methods'} from './prefer-array-last-methods.js';
 export {default as 'prefer-array-some'} from './prefer-array-some.js';
 export {default as 'prefer-at'} from './prefer-at.js';
 export {default as 'prefer-bigint-literals'} from './prefer-bigint-literals.js';
@@ -91,17 +109,21 @@ export {default as 'prefer-code-point'} from './prefer-code-point.js';
 export {default as 'prefer-date-now'} from './prefer-date-now.js';
 export {default as 'prefer-default-parameters'} from './prefer-default-parameters.js';
 export {default as 'prefer-dom-node-append'} from './prefer-dom-node-append.js';
-export {default as 'prefer-dom-node-dataset'} from './prefer-dom-node-dataset.js';
 export {default as 'prefer-dom-node-remove'} from './prefer-dom-node-remove.js';
 export {default as 'prefer-dom-node-text-content'} from './prefer-dom-node-text-content.js';
 export {default as 'prefer-event-target'} from './prefer-event-target.js';
 export {default as 'prefer-export-from'} from './prefer-export-from.js';
+export {default as 'prefer-get-or-insert-computed'} from './prefer-get-or-insert-computed.js';
 export {default as 'prefer-global-this'} from './prefer-global-this.js';
+export {default as 'prefer-https'} from './prefer-https.js';
 export {default as 'prefer-import-meta-properties'} from './prefer-import-meta-properties.js';
+export {default as 'prefer-includes-over-repeated-comparisons'} from './prefer-includes-over-repeated-comparisons.js';
 export {default as 'prefer-includes'} from './prefer-includes.js';
-export {default as 'prefer-json-parse-buffer'} from './prefer-json-parse-buffer.js';
+export {default as 'prefer-iterator-concat'} from './prefer-iterator-concat.js';
+export {default as 'prefer-iterator-to-array-at-end'} from './prefer-iterator-to-array-at-end.js';
 export {default as 'prefer-keyboard-event-key'} from './prefer-keyboard-event-key.js';
 export {default as 'prefer-logical-operator-over-ternary'} from './prefer-logical-operator-over-ternary.js';
+export {default as 'prefer-math-abs'} from './prefer-math-abs.js';
 export {default as 'prefer-math-min-max'} from './prefer-math-min-max.js';
 export {default as 'prefer-math-trunc'} from './prefer-math-trunc.js';
 export {default as 'prefer-modern-dom-apis'} from './prefer-modern-dom-apis.js';
@@ -115,6 +137,7 @@ export {default as 'prefer-object-from-entries'} from './prefer-object-from-entr
 export {default as 'prefer-optional-catch-binding'} from './prefer-optional-catch-binding.js';
 export {default as 'prefer-prototype-methods'} from './prefer-prototype-methods.js';
 export {default as 'prefer-query-selector'} from './prefer-query-selector.js';
+export {default as 'prefer-queue-microtask'} from './prefer-queue-microtask.js';
 export {default as 'prefer-reflect-apply'} from './prefer-reflect-apply.js';
 export {default as 'prefer-regexp-test'} from './prefer-regexp-test.js';
 export {default as 'prefer-response-static-json'} from './prefer-response-static-json.js';
@@ -122,8 +145,12 @@ export {default as 'prefer-set-has'} from './prefer-set-has.js';
 export {default as 'prefer-set-size'} from './prefer-set-size.js';
 export {default as 'prefer-simple-condition-first'} from './prefer-simple-condition-first.js';
 export {default as 'prefer-single-call'} from './prefer-single-call.js';
+export {default as 'prefer-split-limit'} from './prefer-split-limit.js';
 export {default as 'prefer-spread'} from './prefer-spread.js';
+export {default as 'prefer-string-match-all'} from './prefer-string-match-all.js';
+export {default as 'prefer-string-pad-start-end'} from './prefer-string-pad-start-end.js';
 export {default as 'prefer-string-raw'} from './prefer-string-raw.js';
+export {default as 'prefer-string-repeat'} from './prefer-string-repeat.js';
 export {default as 'prefer-string-replace-all'} from './prefer-string-replace-all.js';
 export {default as 'prefer-string-slice'} from './prefer-string-slice.js';
 export {default as 'prefer-string-starts-ends-with'} from './prefer-string-starts-ends-with.js';
@@ -136,9 +163,11 @@ export {default as 'prefer-type-error'} from './prefer-type-error.js';
 export {default as 'prevent-abbreviations'} from './prevent-abbreviations.js';
 export {default as 'relative-url-style'} from './relative-url-style.js';
 export {default as 'require-array-join-separator'} from './require-array-join-separator.js';
+export {default as 'require-css-escape'} from './require-css-escape.js';
 export {default as 'require-module-attributes'} from './require-module-attributes.js';
 export {default as 'require-module-specifiers'} from './require-module-specifiers.js';
 export {default as 'require-number-to-fixed-digits-argument'} from './require-number-to-fixed-digits-argument.js';
+export {default as 'require-passive-events'} from './require-passive-events.js';
 export {default as 'require-post-message-target-origin'} from './require-post-message-target-origin.js';
 export {default as 'string-content'} from './string-content.js';
 export {default as 'switch-case-braces'} from './switch-case-braces.js';
@@ -146,3 +175,4 @@ export {default as 'switch-case-break-position'} from './switch-case-break-posit
 export {default as 'template-indent'} from './template-indent.js';
 export {default as 'text-encoding-identifier-case'} from './text-encoding-identifier-case.js';
 export {default as 'throw-new-error'} from './throw-new-error.js';
+export {default as 'try-complexity'} from './try-complexity.js';

package/rules/isolated-functions.js

@@ -53,7 +53,7 @@ const create = context => {
 				}
 
 				const globalsValue = allowedGlobals[identifier.name];
-				const isGlobalWritable = globalsValue === true || globalsValue === 'writable' || globalsValue === 'writeable';
+				const isGlobalWritable = [true, 'writable', 'writeable'].includes(globalsValue);
 				if (isGlobalWritable) {
 					continue;
 				}
@@ -82,10 +82,12 @@ const create = context => {
 		let commentableNode = node;
 		while (
 			!isComment(previousToken)
-			&& (commentableNode.parent.type === 'VariableDeclarator'
-				|| commentableNode.parent.type === 'VariableDeclaration'
-				|| commentableNode.parent.type === 'ExportNamedDeclaration'
-				|| commentableNode.parent.type === 'ExportDefaultDeclaration')
+			&& [
+				'VariableDeclarator',
+				'VariableDeclaration',
+				'ExportNamedDeclaration',
+				'ExportDefaultDeclaration',
+			].includes(commentableNode.parent.type)
 		) {
 			commentableNode = commentableNode.parent;
 			previousToken = sourceCode.getTokenBefore(commentableNode, {includeComments: true});

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

@@ -23,12 +23,12 @@ const messages = {
 const isClassKeywordToken = token => token.type === 'Keyword' && token.value === 'class';
 const isAnonymousClassOrFunction = node =>
 	(
-		(
-			node.type === 'FunctionDeclaration'
-			|| node.type === 'FunctionExpression'
-			|| node.type === 'ClassDeclaration'
-			|| node.type === 'ClassExpression'
-		)
+		[
+			'FunctionDeclaration',
+			'FunctionExpression',
+			'ClassDeclaration',
+			'ClassExpression',
+		].includes(node.type)
 		&& !node.id
 	)
 	|| node.type === 'ArrowFunctionExpression';