@alexlit/lint-kit 176.0.0 → 177.0.0

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

@@ -1,101 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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;