@alexlit/lint-kit 175.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-useless-collection-argument.js

@@ -0,0 +1,101 @@
+import {isParenthesized, getParenthesizedRange} from './utils/index.js';
+import {
+	isNewExpression,
+	isEmptyArrayExpression,
+	isEmptyStringLiteral,
+	isNullLiteral,
+	isUndefined,
+} from './ast/index.js';
+import {removeParentheses, removeArgument} from './fix/index.js';
+
+const MESSAGE_ID = 'no-useless-collection-argument';
+const messages = {
+	[MESSAGE_ID]: 'The {{description}} is useless.',
+};
+
+const getDescription = node => {
+	if (isEmptyArrayExpression(node)) {
+		return 'empty array';
+	}
+
+	if (isEmptyStringLiteral(node)) {
+		return 'empty string';
+	}
+
+	if (isNullLiteral(node)) {
+		return '`null`';
+	}
+
+	if (isUndefined(node)) {
+		return '`undefined`';
+	}
+};
+
+const removeFallback = (node, context) =>
+	// Same code from rules/no-useless-fallback-in-spread.js
+	/** @param {import('eslint').Rule.RuleFixer} fixer */
+	function * fix(fixer) {
+		const {sourceCode} = context;
+		const logicalExpression = node.parent;
+		const {left} = logicalExpression;
+		const isLeftObjectParenthesized = isParenthesized(left, sourceCode);
+		const [, start] = isLeftObjectParenthesized
+			? getParenthesizedRange(left, context)
+			: sourceCode.getRange(left);
+		const [, end] = sourceCode.getRange(logicalExpression);
+
+		yield fixer.removeRange([start, end]);
+
+		if (
+			isLeftObjectParenthesized
+			|| left.type !== 'SequenceExpression'
+		) {
+			yield removeParentheses(logicalExpression, fixer, context);
+		}
+	};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	NewExpression(newExpression) {
+		if (!isNewExpression(newExpression, {
+			names: ['Set', 'Map', 'WeakSet', 'WeakMap'],
+			argumentsLength: 1,
+		})) {
+			return;
+		}
+
+		const [iterable] = newExpression.arguments;
+		const isCheckingFallback = iterable.type === 'LogicalExpression' && iterable.operator === '??';
+		const node = isCheckingFallback ? iterable.right : iterable;
+		const description = getDescription(node);
+
+		if (!description) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			data: {description},
+			fix: isCheckingFallback
+				? removeFallback(node, context)
+				: fixer => removeArgument(fixer, node, context),
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless values or fallbacks in `Set`, `Map`, `WeakSet`, or `WeakMap`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-useless-error-capture-stack-trace.js

@@ -0,0 +1,146 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {
+	isMethodCall,
+	isMemberExpression,
+} from './ast/index.js';
+import builtinErrors from './shared/builtin-errors.js';
+
+const MESSAGE_ID_ERROR = 'no-useless-error-capture-stack-trace/error';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Unnecessary `Error.captureStackTrace(…)` call.',
+};
+
+const isSubclassOfBuiltinErrors = (node, context) =>
+	node?.superClass
+	&& node.superClass.type === 'Identifier'
+	&& builtinErrors.includes(node.superClass.name)
+	&& context.sourceCode.isGlobalReference(node.superClass);
+
+const isClassReference = (node, classNode, context) => {
+	// `new.target`
+	if (
+		node.type === 'MetaProperty'
+		&& node.meta.type === 'Identifier'
+		&& node.meta.name === 'new'
+		&& node.property.type === 'Identifier'
+		&& node.property.name === 'target'
+	) {
+		return true;
+	}
+
+	// `this.constructor`
+	if (
+		isMemberExpression(node, {
+			property: 'constructor',
+			computed: false,
+			optional: false,
+		})
+		&& node.object.type === 'ThisExpression'
+	) {
+		return true;
+	}
+
+	if (node.type !== 'Identifier' || !classNode.id) {
+		return false;
+	}
+
+	const scope = context.sourceCode.getScope(node);
+	const variable = findVariable(scope, node);
+
+	return variable
+		&& variable.defs.length === 1
+		&& variable.defs[0].type === 'ClassName'
+		&& variable.defs[0].node === classNode;
+};
+
+const isClassConstructor = (node, classNode) =>
+	node
+	&& node.parent.type === 'MethodDefinition'
+	&& node.parent.kind === 'constructor'
+	&& node.parent.value === node
+	&& classNode.body.body.includes(node.parent);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const classStack = [];
+	const thisScopeStack = [];
+
+	context.on(['ClassDeclaration', 'ClassExpression'], classNode => {
+		classStack.push(classNode);
+		thisScopeStack.push(classNode);
+	});
+
+	context.onExit(['ClassDeclaration', 'ClassExpression'], () => {
+		classStack.pop();
+		thisScopeStack.pop();
+	});
+
+	context.on(['FunctionDeclaration', 'FunctionExpression'], functionNode => {
+		thisScopeStack.push(functionNode);
+	});
+
+	context.onExit(['FunctionDeclaration', 'FunctionExpression'], () => {
+		thisScopeStack.pop();
+	});
+
+	context.on('CallExpression', callExpression => {
+		const errorClass = classStack.at(-1);
+
+		if (!(
+			isSubclassOfBuiltinErrors(errorClass, context)
+			&& isClassConstructor(thisScopeStack.at(-1), errorClass)
+			&& isMethodCall(callExpression, {
+				object: 'Error',
+				method: 'captureStackTrace',
+				argumentsLength: 2,
+				optionalMember: false,
+			})
+			&& context.sourceCode.isGlobalReference(callExpression.callee.object)
+		)) {
+			return;
+		}
+
+		const [firstArgument, secondArgument] = callExpression.arguments;
+
+		if (
+			firstArgument.type !== 'ThisExpression'
+			|| !isClassReference(secondArgument, errorClass, context)
+		) {
+			return;
+		}
+
+		const problem = {
+			node: callExpression,
+			messageId: MESSAGE_ID_ERROR,
+		};
+
+		const maybeExpressionStatement = callExpression.parent === 'ChainExpression'
+			? callExpression.parent.parent
+			: callExpression.parent;
+
+		if (
+			maybeExpressionStatement.type === 'ExpressionStatement'
+			&& maybeExpressionStatement.parent.type === 'BlockStatement'
+		) {
+			problem.fix = fixer => fixer.remove(maybeExpressionStatement);
+		}
+
+		return problem;
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow unnecessary `Error.captureStackTrace(…)`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-useless-fallback-in-spread.js

@@ -0,0 +1,66 @@
+import {isParenthesized, getParenthesizedRange} from './utils/parentheses.js';
+import {removeParentheses} from './fix/index.js';
+
+const MESSAGE_ID = 'no-useless-fallback-in-spread';
+const messages = {
+	[MESSAGE_ID]: 'The empty object is useless.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	ObjectExpression(node) {
+		if (!(
+			node.properties.length === 0
+			&& node.parent.type === 'LogicalExpression'
+			&& node.parent.right === node
+			&& (node.parent.operator === '||' || node.parent.operator === '??')
+			&& node.parent.parent.type === 'SpreadElement'
+			&& node.parent.parent.argument === node.parent
+			&& node.parent.parent.parent.type === 'ObjectExpression'
+			&& node.parent.parent.parent.properties.includes(node.parent.parent)
+		)) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			* fix(fixer) {
+				const {sourceCode} = context;
+				const logicalExpression = node.parent;
+				const {left} = logicalExpression;
+				const isLeftObjectParenthesized = isParenthesized(left, sourceCode);
+				const [, start] = isLeftObjectParenthesized
+					? getParenthesizedRange(left, context)
+					: sourceCode.getRange(left);
+				const [, end] = sourceCode.getRange(logicalExpression);
+
+				yield fixer.removeRange([start, end]);
+
+				if (
+					isLeftObjectParenthesized
+					|| left.type !== 'SequenceExpression'
+				) {
+					yield removeParentheses(logicalExpression, fixer, context);
+				}
+			},
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless fallback when spreading in object literals.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-useless-length-check.js

@@ -0,0 +1,150 @@
+import {isMethodCall, isMemberExpression} from './ast/index.js';
+import {getParenthesizedRange, isSameReference, isLogicalExpression} from './utils/index.js';
+
+const messages = {
+	'non-zero': 'The non-empty check is useless as `Array#some()` returns `false` for an empty array.',
+	zero: 'The empty check is useless as `Array#every()` returns `true` for an empty array.',
+};
+
+// We assume the user already follows `unicorn/explicit-length-check`. These are allowed in that rule.
+const isLengthCompareZero = node =>
+	node.type === 'BinaryExpression'
+	&& node.right.type === 'Literal'
+	&& node.right.raw === '0'
+	&& isMemberExpression(node.left, {property: 'length', optional: false})
+	&& isLogicalExpression(node.parent);
+
+function flatLogicalExpression(node) {
+	return [node.left, node.right].flatMap(child =>
+		child.type === 'LogicalExpression' && child.operator === node.operator
+			? flatLogicalExpression(child)
+			: [child],
+	);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const logicalExpressions = [];
+	const zeroLengthChecks = new Set();
+	const nonZeroLengthChecks = new Set();
+	const arraySomeCalls = new Set();
+	const arrayEveryCalls = new Set();
+
+	function isUselessLengthCheckNode({node, operator, siblings}) {
+		return (
+			(
+				operator === '||'
+				&& zeroLengthChecks.has(node)
+				&& siblings.some(condition =>
+					arrayEveryCalls.has(condition)
+					&& isSameReference(node.left.object, condition.callee.object),
+				)
+			)
+			|| (
+				operator === '&&'
+				&& nonZeroLengthChecks.has(node)
+				&& siblings.some(condition =>
+					arraySomeCalls.has(condition)
+					&& isSameReference(node.left.object, condition.callee.object),
+				)
+			)
+		);
+	}
+
+	function getUselessLengthCheckNode(logicalExpression) {
+		const {operator} = logicalExpression;
+		return flatLogicalExpression(logicalExpression)
+			.filter((node, index, conditions) => isUselessLengthCheckNode({
+				node,
+				operator,
+				siblings: [
+					conditions[index - 1],
+					conditions[index + 1],
+				].filter(Boolean),
+			}));
+	}
+
+	return {
+		BinaryExpression(node) {
+			if (isLengthCompareZero(node)) {
+				const {operator} = node;
+				if (operator === '===') {
+					zeroLengthChecks.add(node);
+				} else if (operator === '>' || operator === '!==') {
+					nonZeroLengthChecks.add(node);
+				}
+			}
+		},
+		CallExpression(node) {
+			if (
+				isMethodCall(node, {
+					optionalCall: false,
+					optionalMember: false,
+					computed: false,
+				})
+				&& node.callee.property.type === 'Identifier'
+			) {
+				if (node.callee.property.name === 'some') {
+					arraySomeCalls.add(node);
+				} else if (node.callee.property.name === 'every') {
+					arrayEveryCalls.add(node);
+				}
+			}
+		},
+		LogicalExpression(node) {
+			if (isLogicalExpression(node)) {
+				logicalExpressions.push(node);
+			}
+		},
+		* 'Program:exit'() {
+			const nodes = new Set(
+				logicalExpressions.flatMap(logicalExpression =>
+					getUselessLengthCheckNode(logicalExpression),
+				),
+			);
+			const {sourceCode} = context;
+
+			for (const node of nodes) {
+				yield {
+					loc: {
+						start: sourceCode.getLoc(node.left.property).start,
+						end: sourceCode.getLoc(node).end,
+					},
+					messageId: zeroLengthChecks.has(node) ? 'zero' : 'non-zero',
+					/** @param {import('eslint').Rule.RuleFixer} fixer */
+					fix(fixer) {
+						const {left, right} = node.parent;
+						const leftRange = getParenthesizedRange(left, context);
+						const rightRange = getParenthesizedRange(right, context);
+						const range = [];
+						if (left === node) {
+							range[0] = leftRange[0];
+							range[1] = rightRange[0];
+						} else {
+							range[0] = leftRange[1];
+							range[1] = rightRange[1];
+						}
+
+						return fixer.removeRange(range);
+					},
+				};
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless array length check.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-useless-promise-resolve-reject.js

@@ -0,0 +1,210 @@
+import {getParenthesizedRange} from './utils/index.js';
+import {isFunction, isMethodCall} from './ast/index.js';
+
+const MESSAGE_ID_RESOLVE = 'resolve';
+const MESSAGE_ID_REJECT = 'reject';
+const messages = {
+	[MESSAGE_ID_RESOLVE]: 'Prefer `{{type}} value` over `{{type}} Promise.resolve(value)`.',
+	[MESSAGE_ID_REJECT]: 'Prefer `throw error` over `{{type}} Promise.reject(error)`.',
+};
+
+function getFunctionNode(node) {
+	let isInTryStatement = false;
+	let functionNode;
+	for (; node; node = node.parent) {
+		if (isFunction(node)) {
+			functionNode = node;
+			break;
+		}
+
+		if (node.type === 'TryStatement') {
+			isInTryStatement = true;
+		}
+	}
+
+	return {
+		functionNode,
+		isInTryStatement,
+	};
+}
+
+function isPromiseCallback(node) {
+	if (
+		node.parent.type === 'CallExpression'
+		&& node.parent.callee.type === 'MemberExpression'
+		&& !node.parent.callee.computed
+		&& node.parent.callee.property.type === 'Identifier'
+	) {
+		const {callee: {property}, arguments: arguments_} = node.parent;
+
+		if (
+			arguments_.length === 1
+			&& (
+				property.name === 'then'
+				|| property.name === 'catch'
+				|| property.name === 'finally'
+			)
+			&& arguments_[0] === node
+		) {
+			return true;
+		}
+
+		if (
+			arguments_.length === 2
+			&& property.name === 'then'
+			&& (
+				arguments_[0] === node
+				|| (arguments_[0].type !== 'SpreadElement' && arguments_[1] === node)
+			)
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function createProblem(callExpression, fix) {
+	const {callee, parent} = callExpression;
+	const method = callee.property.name;
+	const type = parent.type === 'YieldExpression' ? 'yield' : 'return';
+
+	return {
+		node: callee,
+		messageId: method,
+		data: {type},
+		fix,
+	};
+}
+
+function fix(callExpression, isInTryStatement, context) {
+	if (callExpression.arguments.length > 1) {
+		return;
+	}
+
+	const {callee, parent, arguments: [errorOrValue]} = callExpression;
+	if (errorOrValue?.type === 'SpreadElement') {
+		return;
+	}
+
+	const isReject = callee.property.name === 'reject';
+	const isYieldExpression = parent.type === 'YieldExpression';
+	if (
+		isReject
+		&& (
+			isInTryStatement
+			|| (isYieldExpression && parent.parent.type !== 'ExpressionStatement')
+		)
+	) {
+		return;
+	}
+
+	return function (fixer) {
+		const isArrowFunctionBody = parent.type === 'ArrowFunctionExpression';
+
+		let text = errorOrValue ? context.sourceCode.getText(errorOrValue) : '';
+
+		if (errorOrValue?.type === 'SequenceExpression') {
+			text = `(${text})`;
+		}
+
+		if (isReject) {
+			// `return Promise.reject()` -> `throw undefined`
+			text ||= 'undefined';
+			text = `throw ${text}`;
+
+			if (isYieldExpression) {
+				return fixer.replaceTextRange(
+					getParenthesizedRange(parent, context),
+					text,
+				);
+			}
+
+			text += ';';
+
+			// `=> Promise.reject(error)` -> `=> { throw error; }`
+			if (isArrowFunctionBody) {
+				text = `{ ${text} }`;
+				return fixer.replaceTextRange(
+					getParenthesizedRange(callExpression, context),
+					text,
+				);
+			}
+		} else {
+			// eslint-disable-next-line no-lonely-if
+			if (isYieldExpression) {
+				text = `yield${text ? ' ' : ''}${text}`;
+			} else if (parent.type === 'ReturnStatement') {
+				text = `return${text ? ' ' : ''}${text};`;
+			} else {
+				if (errorOrValue?.type === 'ObjectExpression') {
+					text = `(${text})`;
+				}
+
+				// `=> Promise.resolve()` -> `=> {}`
+				text ||= '{}';
+			}
+		}
+
+		return fixer.replaceText(
+			isArrowFunctionBody ? callExpression : parent,
+			text,
+		);
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('CallExpression', callExpression => {
+		if (!(
+			isMethodCall(callExpression, {
+				object: 'Promise',
+				methods: ['resolve', 'reject'],
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& (
+				(
+					callExpression.parent.type === 'ArrowFunctionExpression'
+					&& callExpression.parent.body === callExpression
+				)
+				|| (
+					callExpression.parent.type === 'ReturnStatement'
+					&& callExpression.parent.argument === callExpression
+				)
+				|| (
+					callExpression.parent.type === 'YieldExpression'
+					&& !callExpression.parent.delegate && callExpression.parent.argument === callExpression
+				)
+			)
+		)) {
+			return;
+		}
+
+		const {functionNode, isInTryStatement} = getFunctionNode(callExpression);
+		if (!functionNode || !(functionNode.async || isPromiseCallback(functionNode))) {
+			return;
+		}
+
+		return createProblem(
+			callExpression,
+			fix(callExpression, isInTryStatement, context),
+		);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow returning/yielding `Promise.resolve/reject()` in async functions or promise callbacks',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;