eslint-plugin-unicorn 67.0.0 → 69.0.0

package/rules/default-export-style.js

@@ -0,0 +1,569 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {
+	getComments,
+	getParenthesizedText,
+	hasUnsafeArrowConversionReference,
+} from './utils/index.js';
+
+const MESSAGE_ID_INLINE = 'default-export-style/inline';
+const MESSAGE_ID_SEPARATE = 'default-export-style/separate';
+const MESSAGE_ID_SUGGESTION_INLINE = 'default-export-style/suggestion-inline';
+const MESSAGE_ID_SUGGESTION_SEPARATE = 'default-export-style/suggestion-separate';
+
+const STYLE_INLINE = 'inline';
+const STYLE_SEPARATE = 'separate';
+const STYLE_IGNORE = 'ignore';
+
+const KIND_CLASS = 'class';
+const KIND_FUNCTION = 'function';
+
+const messages = {
+	[MESSAGE_ID_INLINE]: 'Prefer declaring this default-exported {{kind}} inline.',
+	[MESSAGE_ID_SEPARATE]: 'Prefer declaring this default-exported {{kind}} as a separate {{style}}.',
+	[MESSAGE_ID_SUGGESTION_INLINE]: 'Use an inline default {{kind}} declaration.',
+	[MESSAGE_ID_SUGGESTION_SEPARATE]: 'Use a separate const arrow function default export.',
+};
+
+const defaultOptions = {
+	functions: STYLE_INLINE,
+	classes: STYLE_INLINE,
+};
+
+const createStyleSchema = () => ({
+	enum: [
+		STYLE_INLINE,
+		STYLE_SEPARATE,
+		STYLE_IGNORE,
+	],
+});
+
+const isExportedIdentifier = (exportDeclaration, name) =>
+	exportDeclaration?.type === 'ExportDefaultDeclaration'
+	&& exportDeclaration.declaration.type === 'Identifier'
+	&& exportDeclaration.declaration.name === name;
+
+const getName = node => node.id?.name;
+
+const getKind = node => {
+	switch (node.type) {
+		case 'ClassDeclaration': {
+			return KIND_CLASS;
+		}
+
+		case 'FunctionDeclaration': {
+			return KIND_FUNCTION;
+		}
+
+		// No default
+	}
+};
+
+const getOptionKey = kind => kind === KIND_CLASS ? 'classes' : 'functions';
+
+const hasCommentsBetween = (context, left, right) => {
+	const [, start] = context.sourceCode.getRange(left);
+	const [end] = context.sourceCode.getRange(right);
+
+	return getComments(context).some(comment => {
+		const [commentStart, commentEnd] = context.sourceCode.getRange(comment);
+		return commentStart >= start && commentEnd <= end;
+	});
+};
+
+const hasTrailingComment = (context, node) => {
+	const [, end] = context.sourceCode.getRange(node);
+	const nodeEndLine = context.sourceCode.getLoc(node).end.line;
+
+	return getComments(context).some(comment =>
+		context.sourceCode.getRange(comment)[0] >= end
+		&& context.sourceCode.getLoc(comment).start.line === nodeEndLine,
+	);
+};
+
+const isBindingReassigned = (scope, identifier) =>
+	findVariable(scope, identifier)?.references.some(reference =>
+		!reference.init && reference.isWrite()) ?? false;
+
+const hasTypeScriptSyntax = node => {
+	if (!node) {
+		return false;
+	}
+
+	return Boolean(
+		node.type.startsWith('TS')
+		|| node.typeAnnotation
+		|| node.typeParameters
+		|| node.returnType
+		|| node.implements?.length > 0
+		|| node.superTypeArguments
+		|| node.accessibility
+		|| node.readonly
+		|| node.override
+		|| node.definite
+		|| (
+			node.optional
+			&& node.type !== 'MemberExpression'
+			&& node.type !== 'CallExpression'
+		)
+		|| node.abstract
+		|| node.declare
+		|| node.decorators?.length > 0,
+	);
+};
+
+const hasTypeScriptSyntaxInTree = (node, visitorKeys) => {
+	if (hasTypeScriptSyntax(node)) {
+		return true;
+	}
+
+	for (const key of visitorKeys[node.type] ?? []) {
+		const value = node[key];
+
+		if (Array.isArray(value)) {
+			if (value.some(child => child?.type && hasTypeScriptSyntaxInTree(child, visitorKeys))) {
+				return true;
+			}
+
+			continue;
+		}
+
+		if (value?.type && hasTypeScriptSyntaxInTree(value, visitorKeys)) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+const hasSafeParametersForArrowConversion = (functionNode, context) =>
+	functionNode.params.every(parameter => !hasUnsafeArrowConversionReference(parameter, context.sourceCode.visitorKeys));
+
+const hasOtherReferences = (scope, identifier, allowedReferenceIdentifier) =>
+	findVariable(scope, identifier)?.references.some(reference =>
+		!reference.init
+		&& reference.identifier !== allowedReferenceIdentifier,
+	) ?? false;
+
+const hasCommentsOutsideFunction = (context, node, functionNode) =>
+	context.sourceCode.getCommentsInside(node).length > context.sourceCode.getCommentsInside(functionNode).length;
+
+const getVariableArrowFunction = (node, context) => {
+	if (
+		node.type !== 'VariableDeclaration'
+		|| node.kind !== 'const'
+		|| node.declarations.length !== 1
+	) {
+		return;
+	}
+
+	const [declarator] = node.declarations;
+
+	if (
+		declarator.id.type !== 'Identifier'
+		|| hasTypeScriptSyntax(declarator.id)
+		|| declarator.init?.type !== 'ArrowFunctionExpression'
+		|| hasTypeScriptSyntaxInTree(declarator.init, context.sourceCode.visitorKeys)
+	) {
+		return;
+	}
+
+	return declarator;
+};
+
+const getSeparateDeclaration = (statement, context) => {
+	const name = getName(statement);
+
+	if (name) {
+		const kind = getKind(statement);
+		return kind && {kind, name, declaration: statement};
+	}
+
+	const arrowFunctionDeclarator = getVariableArrowFunction(statement, context);
+
+	if (arrowFunctionDeclarator) {
+		return {
+			kind: KIND_FUNCTION,
+			name: arrowFunctionDeclarator.id.name,
+			declaration: statement,
+			functionNode: arrowFunctionDeclarator.init,
+		};
+	}
+};
+
+const canConvertFunctionToArrow = (functionNode, context) =>
+	functionNode.type === 'FunctionDeclaration'
+	&& !functionNode.generator
+	&& !hasTypeScriptSyntaxInTree(functionNode, context.sourceCode.visitorKeys)
+	&& context.sourceCode.getCommentsInside(functionNode).length === 0
+	&& hasSafeParametersForArrowConversion(functionNode, context)
+	&& !hasUnsafeArrowConversionReference(functionNode.body, context.sourceCode.visitorKeys);
+
+const canConvertArrowToFunction = (functionNode, context) =>
+	functionNode.type === 'ArrowFunctionExpression'
+	&& !hasTypeScriptSyntaxInTree(functionNode, context.sourceCode.visitorKeys)
+	&& context.sourceCode.getCommentsInside(functionNode).length === 0
+	&& hasSafeParametersForArrowConversion(functionNode, context)
+	&& !hasUnsafeArrowConversionReference(functionNode.body, context.sourceCode.visitorKeys);
+
+const getParametersText = (functionNode, sourceCode) =>
+	functionNode.params.map(parameter => sourceCode.getText(parameter)).join(', ');
+
+const getArrowFunctionBodyText = (functionNode, context) =>
+	functionNode.body.type === 'BlockStatement'
+		? context.sourceCode.getText(functionNode.body)
+		: `{ return ${getParenthesizedText(functionNode.body, context)}; }`;
+
+const getInlineFunctionText = (name, functionNode, context) =>
+	`export default ${functionNode.async ? 'async ' : ''}function ${name}(${getParametersText(functionNode, context.sourceCode)}) ${getArrowFunctionBodyText(functionNode, context)}`;
+
+const getSeparateArrowFunctionText = (name, functionNode, context) =>
+	`const ${name} = ${functionNode.async ? 'async ' : ''}(${getParametersText(functionNode, context.sourceCode)}) => ${context.sourceCode.getText(functionNode.body)};\nexport default ${name};`;
+
+const fixSeparateToInline = (declaration, exportDeclaration, context) => function * (fixer) {
+	yield fixer.insertTextBefore(declaration, 'export default ');
+	yield fixer.removeRange([
+		context.sourceCode.getRange(declaration)[1],
+		context.sourceCode.getRange(exportDeclaration)[1],
+	]);
+};
+
+const fixInlineClassToSeparate = (exportDeclaration, context) => fixer => {
+	const {declaration} = exportDeclaration;
+	return fixer.replaceText(
+		exportDeclaration,
+		`${context.sourceCode.getText(declaration)}\nexport default ${declaration.id.name};`,
+	);
+};
+
+const suggestArrowToInlineFunction = ({
+	context,
+	declaration,
+	exportDeclaration,
+	name,
+	scope,
+}) => {
+	const [{id, init: functionNode}] = declaration.declarations;
+
+	if (
+		context.sourceCode.getCommentsInside(exportDeclaration).length > 0
+		|| hasTrailingComment(context, exportDeclaration)
+		|| hasCommentsOutsideFunction(context, declaration, functionNode)
+		|| hasOtherReferences(scope, id, exportDeclaration.declaration)
+		|| !canConvertArrowToFunction(functionNode, context)
+	) {
+		return;
+	}
+
+	return [
+		{
+			messageId: MESSAGE_ID_SUGGESTION_INLINE,
+			data: {
+				kind: KIND_FUNCTION,
+			},
+			fix: fixer => fixer.replaceTextRange(
+				[
+					context.sourceCode.getRange(declaration)[0],
+					context.sourceCode.getRange(exportDeclaration)[1],
+				],
+				getInlineFunctionText(name, functionNode, context),
+			),
+		},
+	];
+};
+
+const suggestFunctionToSeparateArrow = ({
+	context,
+	declaration,
+	exportDeclaration,
+	name,
+	scope,
+	rangeStartNode = declaration,
+}) => {
+	if (
+		context.sourceCode.getCommentsInside(exportDeclaration).length > context.sourceCode.getCommentsInside(declaration).length
+		|| hasOtherReferences(
+			scope,
+			declaration.id,
+			exportDeclaration.declaration.type === 'Identifier' ? exportDeclaration.declaration : undefined,
+		)
+		|| !canConvertFunctionToArrow(declaration, context)
+	) {
+		return;
+	}
+
+	return [
+		{
+			messageId: MESSAGE_ID_SUGGESTION_SEPARATE,
+			fix: fixer => fixer.replaceTextRange(
+				[
+					context.sourceCode.getRange(rangeStartNode)[0],
+					context.sourceCode.getRange(exportDeclaration)[1],
+				],
+				getSeparateArrowFunctionText(name, declaration, context),
+			),
+		},
+	];
+};
+
+const reportSeparateDeclaration = ({
+	context,
+	declaration,
+	exportDeclaration,
+	expectedStyle,
+	kind,
+	name,
+	scope,
+}) => {
+	if (
+		expectedStyle === STYLE_IGNORE
+		|| hasCommentsBetween(context, declaration, exportDeclaration)
+		|| isBindingReassigned(scope, exportDeclaration.declaration)
+	) {
+		return;
+	}
+
+	if (
+		kind === KIND_FUNCTION
+		&& declaration.type === 'FunctionDeclaration'
+		&& declaration.generator
+	) {
+		return;
+	}
+
+	if (
+		kind === KIND_FUNCTION
+		&& declaration.type === 'FunctionDeclaration'
+		&& hasTypeScriptSyntaxInTree(declaration, context.sourceCode.visitorKeys)
+	) {
+		return;
+	}
+
+	if (expectedStyle === STYLE_INLINE) {
+		if (declaration.type === 'VariableDeclaration') {
+			return {
+				node: exportDeclaration,
+				messageId: MESSAGE_ID_INLINE,
+				data: {kind},
+				suggest: suggestArrowToInlineFunction({
+					context,
+					declaration,
+					exportDeclaration,
+					name,
+					scope,
+				}),
+			};
+		}
+
+		if (
+			kind === KIND_CLASS
+			&& hasTypeScriptSyntaxInTree(declaration, context.sourceCode.visitorKeys)
+		) {
+			return;
+		}
+
+		if (
+			context.sourceCode.getCommentsInside(exportDeclaration).length > 0
+			|| hasTrailingComment(context, exportDeclaration)
+		) {
+			return {
+				node: exportDeclaration,
+				messageId: MESSAGE_ID_INLINE,
+				data: {kind},
+			};
+		}
+
+		return {
+			node: exportDeclaration,
+			messageId: MESSAGE_ID_INLINE,
+			data: {kind},
+			fix: fixSeparateToInline(declaration, exportDeclaration, context),
+		};
+	}
+
+	if (
+		expectedStyle === STYLE_SEPARATE
+		&& kind === KIND_FUNCTION
+		&& declaration.type === 'FunctionDeclaration'
+	) {
+		return {
+			node: exportDeclaration,
+			messageId: MESSAGE_ID_SEPARATE,
+			data: {
+				kind,
+				style: 'const arrow function',
+			},
+			suggest: suggestFunctionToSeparateArrow({
+				context,
+				declaration,
+				exportDeclaration,
+				name,
+				scope,
+			}),
+		};
+	}
+};
+
+const reportInlineDeclaration = ({
+	context,
+	exportDeclaration,
+	expectedStyle,
+	kind,
+}) => {
+	const {declaration} = exportDeclaration;
+	const name = getName(declaration);
+	const exportScope = context.sourceCode.getScope(exportDeclaration);
+
+	if (
+		!name
+		|| expectedStyle === STYLE_IGNORE
+		|| expectedStyle === STYLE_INLINE
+		|| isBindingReassigned(exportScope, name)
+	) {
+		return;
+	}
+
+	if (
+		kind === KIND_FUNCTION
+		&& (
+			declaration.generator
+			|| hasTypeScriptSyntaxInTree(declaration, context.sourceCode.visitorKeys)
+		)
+	) {
+		return;
+	}
+
+	if (kind === KIND_FUNCTION) {
+		return {
+			node: exportDeclaration,
+			messageId: MESSAGE_ID_SEPARATE,
+			data: {
+				kind,
+				style: 'const arrow function',
+			},
+			suggest: suggestFunctionToSeparateArrow({
+				context,
+				declaration,
+				exportDeclaration,
+				name,
+				scope: exportScope,
+				rangeStartNode: exportDeclaration,
+			}),
+		};
+	}
+
+	if (
+		kind === KIND_CLASS
+		&& hasTypeScriptSyntaxInTree(declaration, context.sourceCode.visitorKeys)
+	) {
+		return;
+	}
+
+	if (
+		context.sourceCode.getCommentsInside(exportDeclaration).length
+		> context.sourceCode.getCommentsInside(declaration).length
+	) {
+		return {
+			node: exportDeclaration,
+			messageId: MESSAGE_ID_SEPARATE,
+			data: {
+				kind,
+				style: 'class declaration',
+			},
+		};
+	}
+
+	return {
+		node: exportDeclaration,
+		messageId: MESSAGE_ID_SEPARATE,
+		data: {
+			kind,
+			style: 'class declaration',
+		},
+		fix: fixInlineClassToSeparate(exportDeclaration, context),
+	};
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const options = context.options[0];
+
+	context.on('Program', program => {
+		for (const [index, statement] of program.body.entries()) {
+			if (statement.type === 'ExportDefaultDeclaration') {
+				const {declaration} = statement;
+				const kind = getKind(declaration);
+				const name = getName(declaration);
+
+				if (!kind || !name) {
+					continue;
+				}
+
+				const problem = reportInlineDeclaration({
+					context,
+					exportDeclaration: statement,
+					expectedStyle: options[getOptionKey(kind)],
+					kind,
+				});
+
+				if (problem) {
+					return problem;
+				}
+
+				continue;
+			}
+
+			const nextStatement = program.body[index + 1];
+			const separateDeclaration = getSeparateDeclaration(statement, context);
+
+			if (
+				!separateDeclaration
+				|| !isExportedIdentifier(nextStatement, separateDeclaration.name)
+			) {
+				continue;
+			}
+
+			const problem = reportSeparateDeclaration({
+				context,
+				exportDeclaration: nextStatement,
+				expectedStyle: options[getOptionKey(separateDeclaration.kind)],
+				scope: context.sourceCode.getScope(nextStatement),
+				...separateDeclaration,
+			});
+
+			if (problem) {
+				return problem;
+			}
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce consistent default export declarations.',
+			recommended: true,
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					functions: createStyleSchema(),
+					classes: createStyleSchema(),
+				},
+				additionalProperties: false,
+			},
+		],
+		defaultOptions: [defaultOptions],
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/expiring-todo-comments.js

@@ -210,7 +210,7 @@ function getPackageHelpers(dirname) {
 const DEPENDENCY_INCLUSION_RE = /^[+-]\s*\S{2,}/;
 const VERSION_COMPARISON_RE = /^(?<name>\S{2,})@(?<condition>>|>=)(?<version>\d+(?:\.\d+){0,2}(?:-[\d\-a-z]+(?:\.[\d\-a-z]+)*)?(?:\+[\d\-a-z]+(?:\.[\d\-a-z]+)*)?)/i;
 const PKG_VERSION_RE = /^(?<condition>>|>=)(?<version>\d+(?:\.\d+){0,2}(?:-[\d\-a-z]+(?:\.[\d\-a-z]+)*)?(?:\+[\d\-a-z]+(?:\.[\d\-a-z]+)*)?)\s*$/;
-const ISO8601_DATE = /\d{4}-\d{2}-\d{2}/;
+const ISO8601_DATE = /^\d{4}-\d{2}-\d{2}$/;
 
 function createArgumentGroup(arguments_) {
 	const groups = {};

package/rules/explicit-length-check.js

@@ -1,4 +1,3 @@
-import {getStaticValue} from '@eslint-community/eslint-utils';
 import {
 	isParenthesized,
 	checkVueTemplate,
@@ -9,9 +8,12 @@ import {
 	isSameReference,
 	isTypeScriptExpressionWrapper,
 	unwrapTypeScriptExpression,
+	hasSameObjectShapePropertyCheck,
+	isKnownNonCollectionLengthOrSize,
+	isLengthOrSizeMemberExpression,
 } from './utils/index.js';
 import {fixSpaceAroundKeyword} from './fix/index.js';
-import {isLiteral, isMemberExpression} from './ast/index.js';
+import {isLiteral} from './ast/index.js';
 
 const TYPE_NON_ZERO = 'non-zero';
 const TYPE_ZERO = 'zero';
@@ -51,15 +53,6 @@ const zeroStyle = {
 	test: node => isCompareRight(node, '===', 0),
 };
 
-const shapeProperties = new Set(['depth', 'height', 'width']);
-
-function isLengthOrSizeMemberExpression(node) {
-	return isMemberExpression(node, {
-		properties: ['length', 'size'],
-		optional: false,
-	});
-}
-
 function getLengthCheckParent(node, allowTypeScriptExpression) {
 	node = node.parent;
 	if (allowTypeScriptExpression) {
@@ -89,23 +82,6 @@ function getLogicalExpressionOperands(node) {
 			: [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);
@@ -268,9 +244,8 @@ function create(context) {
 		}
 
 		const lengthNode = memberExpression;
-		const staticValue = getStaticValue(lengthNode, sourceCode.getScope(lengthNode));
-		if (staticValue && (!Number.isSafeInteger(staticValue.value) || staticValue.value < 0)) {
-			// Ignore known, non-positive-integer length properties.
+		if (isKnownNonCollectionLengthOrSize(lengthNode, context)) {
+			// Ignore known non-cardinality length or size properties.
 			return;
 		}
 
@@ -298,7 +273,7 @@ function create(context) {
 		if (node) {
 			if (
 				(node === lengthNode && isLengthGuardedByNonZeroCheck(lengthNode, context))
-				|| hasSameObjectShapePropertyCheck({node, lengthNode})
+				|| hasSameObjectShapePropertyCheck({node, lengthOrSizeNode: lengthNode})
 			) {
 				return;
 			}

package/rules/import-style.js

@@ -53,14 +53,16 @@ const getActualExportDeclarationStyles = exportDeclaration => {
 	const styles = new Set();
 
 	for (const specifier of specifiers) {
-		if (specifier.type === 'ExportSpecifier') {
-			if (specifier.exported.type === 'Identifier' && specifier.exported.name === 'default') {
-				styles.add('default');
-				continue;
-			}
+		if (specifier.type !== 'ExportSpecifier') {
+			continue;
+		}
 
-			styles.add('named');
+		if (specifier.exported.type === 'Identifier' && specifier.exported.name === 'default') {
+			styles.add('default');
+			continue;
 		}
+
+		styles.add('named');
 	}
 
 	return [...styles];