@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-lonely-if.js

@@ -1,155 +0,0 @@
-import {isParenthesized, isNotSemicolonToken} from '@eslint-community/eslint-utils';
-import {needsSemicolon} from './utils/index.js';
-import {removeSpacesAfter} from './fix/index.js';
-
-const MESSAGE_ID = 'no-lonely-if';
-const messages = {
-	[MESSAGE_ID]: 'Unexpected `if` as the only statement in a `if` block without `else`.',
-};
-
-const isIfStatementWithoutAlternate = node => node.type === 'IfStatement' && !node.alternate;
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table
-// Lower precedence than `&&`
-const needParenthesis = node => (
-	(node.type === 'LogicalExpression' && (node.operator === '||' || node.operator === '??'))
-	|| node.type === 'ConditionalExpression'
-	|| node.type === 'AssignmentExpression'
-	|| node.type === 'YieldExpression'
-	|| node.type === 'SequenceExpression'
-);
-
-function getIfStatementTokens(node, sourceCode) {
-	const tokens = {
-		ifToken: sourceCode.getFirstToken(node),
-		openingParenthesisToken: sourceCode.getFirstToken(node, 1),
-	};
-
-	const {consequent} = node;
-	tokens.closingParenthesisToken = sourceCode.getTokenBefore(consequent);
-
-	if (consequent.type === 'BlockStatement') {
-		tokens.openingBraceToken = sourceCode.getFirstToken(consequent);
-		tokens.closingBraceToken = sourceCode.getLastToken(consequent);
-	}
-
-	return tokens;
-}
-
-function fix(innerIfStatement, context) {
-	const {sourceCode} = context;
-
-	return function * (fixer) {
-		const outerIfStatement = (
-			innerIfStatement.parent.type === 'BlockStatement'
-				? innerIfStatement.parent
-				: innerIfStatement
-		).parent;
-		const outer = {
-			...outerIfStatement,
-			...getIfStatementTokens(outerIfStatement, sourceCode),
-		};
-		const inner = {
-			...innerIfStatement,
-			...getIfStatementTokens(innerIfStatement, sourceCode),
-		};
-
-		// Remove inner `if` token
-		yield fixer.remove(inner.ifToken);
-		yield removeSpacesAfter(inner.ifToken, context, fixer);
-
-		// Remove outer `{}`
-		if (outer.openingBraceToken) {
-			yield fixer.remove(outer.openingBraceToken);
-			yield removeSpacesAfter(outer.openingBraceToken, context, fixer);
-			yield fixer.remove(outer.closingBraceToken);
-
-			const tokenBefore = sourceCode.getTokenBefore(outer.closingBraceToken, {includeComments: true});
-			yield removeSpacesAfter(tokenBefore, context, fixer);
-		}
-
-		// Add new `()`
-		yield fixer.insertTextBefore(outer.openingParenthesisToken, '(');
-		yield fixer.insertTextAfter(
-			inner.closingParenthesisToken,
-			`)${inner.consequent.type === 'EmptyStatement' ? '' : ' '}`,
-		);
-
-		// Add ` && `
-		yield fixer.insertTextAfter(outer.closingParenthesisToken, ' && ');
-
-		// Remove `()` if `test` don't need it
-		for (const {test, openingParenthesisToken, closingParenthesisToken} of [outer, inner]) {
-			if (
-				isParenthesized(test, sourceCode)
-				|| !needParenthesis(test)
-			) {
-				yield fixer.remove(openingParenthesisToken);
-				yield fixer.remove(closingParenthesisToken);
-			}
-
-			yield removeSpacesAfter(closingParenthesisToken, context, fixer);
-		}
-
-		// If the `if` statement has no block, and is not followed by a semicolon,
-		// make sure that fixing the issue would not change semantics due to ASI.
-		// Similar logic https://github.com/eslint/eslint/blob/2124e1b5dad30a905dc26bde9da472bf622d3f50/lib/rules/no-lonely-if.js#L61-L77
-		if (inner.consequent.type !== 'BlockStatement') {
-			const lastToken = sourceCode.getLastToken(inner.consequent);
-			if (isNotSemicolonToken(lastToken)) {
-				const nextToken = sourceCode.getTokenAfter(outer);
-				if (nextToken && needsSemicolon(lastToken, context, nextToken.value)) {
-					yield fixer.insertTextBefore(nextToken, ';');
-				}
-			}
-		}
-	};
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	IfStatement(ifStatement) {
-		if (!(
-			isIfStatementWithoutAlternate(ifStatement)
-			&& (
-				// `if (a) { if (b) {} }`
-				(
-					ifStatement.parent.type === 'BlockStatement'
-					&& ifStatement.parent.body.length === 1
-					&& ifStatement.parent.body[0] === ifStatement
-					&& isIfStatementWithoutAlternate(ifStatement.parent.parent)
-					&& ifStatement.parent.parent.consequent === ifStatement.parent
-				)
-				// `if (a) if (b) {}`
-				|| (
-					isIfStatementWithoutAlternate(ifStatement.parent)
-					&& ifStatement.parent.consequent === ifStatement
-				)
-			)
-		)) {
-			return;
-		}
-
-		return {
-			node: ifStatement,
-			messageId: MESSAGE_ID,
-			fix: fix(ifStatement, context),
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow `if` statements as the only statement in `if` blocks without `else`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-magic-array-flat-depth.js

@@ -1,55 +0,0 @@
-import {isMethodCall, isNumericLiteral} from './ast/index.js';
-import {getCallExpressionTokens} from './utils/index.js';
-
-const MESSAGE_ID = 'no-magic-array-flat-depth';
-const messages = {
-	[MESSAGE_ID]: 'Magic number as depth is not allowed.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	CallExpression(callExpression) {
-		if (!isMethodCall(callExpression, {
-			method: 'flat',
-			argumentsLength: 1,
-			optionalCall: false,
-		})) {
-			return;
-		}
-
-		const [depth] = callExpression.arguments;
-
-		if (!isNumericLiteral(depth) || depth.value === 1) {
-			return;
-		}
-
-		const {sourceCode} = context;
-		const {
-			openingParenthesisToken,
-			closingParenthesisToken,
-		} = getCallExpressionTokens(callExpression, context);
-		if (sourceCode.commentsExistBetween(openingParenthesisToken, closingParenthesisToken)) {
-			return;
-		}
-
-		return {
-			node: depth,
-			messageId: MESSAGE_ID,
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow a magic number as the `depth` argument in `Array#flat(…).`',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-named-default.js

@@ -1,101 +0,0 @@
-import {removeSpecifier} from './fix/index.js';
-import assertToken from './utils/assert-token.js';
-
-const MESSAGE_ID = 'no-named-default';
-const messages = {
-	[MESSAGE_ID]: 'Prefer using the default {{type}} over named {{type}}.',
-};
-
-const isValueImport = node => !node.importKind || node.importKind === 'value';
-const isValueExport = node => !node.exportKind || node.exportKind === 'value';
-
-const fixImportSpecifier = (importSpecifier, context) => function * (fixer) {
-	const {sourceCode} = context;
-	const declaration = importSpecifier.parent;
-
-	yield removeSpecifier(importSpecifier, fixer, context, /* keepDeclaration */ true);
-
-	const nameText = sourceCode.getText(importSpecifier.local);
-	const hasDefaultImport = declaration.specifiers.some(({type}) => type === 'ImportDefaultSpecifier');
-
-	// Insert a new `ImportDeclaration`
-	if (hasDefaultImport) {
-		const fromToken = sourceCode.getTokenBefore(declaration.source, token => token.type === 'Identifier' && token.value === 'from');
-		const [startOfFromToken] = sourceCode.getRange(fromToken);
-		const [, endOfDeclaration] = sourceCode.getRange(declaration);
-		const text = `import ${nameText} ${sourceCode.text.slice(startOfFromToken, endOfDeclaration)}`;
-		yield fixer.insertTextBefore(declaration, `${text}\n`);
-
-		return;
-	}
-
-	const importToken = sourceCode.getFirstToken(declaration);
-	assertToken(importToken, {
-		expected: {type: 'Keyword', value: 'import'},
-		ruleId: 'no-named-default',
-	});
-
-	const shouldAddComma = declaration.specifiers.some(specifier => specifier !== importSpecifier && specifier.type === importSpecifier.type);
-	yield fixer.insertTextAfter(importToken, ` ${nameText}${shouldAddComma ? ',' : ''}`);
-};
-
-const fixExportSpecifier = (exportSpecifier, context) => function * (fixer) {
-	const declaration = exportSpecifier.parent;
-	yield removeSpecifier(exportSpecifier, fixer, context);
-
-	const text = `export default ${context.sourceCode.getText(exportSpecifier.local)};`;
-	yield fixer.insertTextBefore(declaration, `${text}\n`);
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	ImportSpecifier(specifier) {
-		if (!(
-			isValueImport(specifier)
-			&& specifier.imported.name === 'default'
-			&& isValueImport(specifier.parent)
-		)) {
-			return;
-		}
-
-		return {
-			node: specifier,
-			messageId: MESSAGE_ID,
-			data: {type: 'import'},
-			fix: fixImportSpecifier(specifier, context),
-		};
-	},
-	ExportSpecifier(specifier) {
-		if (!(
-			isValueExport(specifier)
-			&& specifier.exported.name === 'default'
-			&& isValueExport(specifier.parent)
-			&& !specifier.parent.source
-		)) {
-			return;
-		}
-
-		return {
-			node: specifier,
-			messageId: MESSAGE_ID,
-			data: {type: 'export'},
-			fix: fixExportSpecifier(specifier, context),
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow named usage of default import and export.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-negated-condition.js

@@ -1,145 +0,0 @@
-/*
-Based on ESLint builtin `no-negated-condition` rule
-https://github.com/eslint/eslint/blob/5c39425fc55ecc0b97bbd07ac22654c0eb4f789c/lib/rules/no-negated-condition.js
-*/
-import {
-	removeParentheses,
-	fixSpaceAroundKeyword,
-	addParenthesizesToReturnOrThrowExpression,
-} from './fix/index.js';
-import {getParenthesizedRange, isParenthesized} from './utils/parentheses.js';
-import isOnSameLine from './utils/is-on-same-line.js';
-import needsSemicolon from './utils/needs-semicolon.js';
-
-const MESSAGE_ID = 'no-negated-condition';
-const messages = {
-	[MESSAGE_ID]: 'Unexpected negated condition.',
-};
-
-function * convertNegatedCondition(fixer, node, context) {
-	const {sourceCode} = context;
-	const {test} = node;
-	if (test.type === 'UnaryExpression') {
-		const token = sourceCode.getFirstToken(test);
-
-		if (node.type === 'IfStatement') {
-			yield removeParentheses(test.argument, fixer, context);
-		}
-
-		yield fixer.remove(token);
-		return;
-	}
-
-	const token = sourceCode.getTokenAfter(
-		test.left,
-		token => token.type === 'Punctuator' && token.value === test.operator,
-	);
-
-	yield fixer.replaceText(token, '=' + token.value.slice(1));
-}
-
-function * swapConsequentAndAlternate(fixer, node, context) {
-	const isIfStatement = node.type === 'IfStatement';
-	const [consequent, alternate] = [
-		node.consequent,
-		node.alternate,
-	].map(node => {
-		const range = getParenthesizedRange(node, context);
-		let text = context.sourceCode.text.slice(...range);
-		// `if (!a) b(); else c()` can't fix to `if (!a) c() else b();`
-		if (isIfStatement && node.type !== 'BlockStatement') {
-			text = `{${text}}`;
-		}
-
-		return {
-			range,
-			text,
-		};
-	});
-
-	if (consequent.text === alternate.text) {
-		return;
-	}
-
-	const {sourceCode} = context;
-	yield fixer.replaceTextRange(sourceCode.getRange(consequent), alternate.text);
-	yield fixer.replaceTextRange(sourceCode.getRange(alternate), consequent.text);
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on(['IfStatement', 'ConditionalExpression'], node => {
-		if (
-			node.type === 'IfStatement'
-			&& (
-				!node.alternate
-				|| node.alternate.type === 'IfStatement'
-			)
-		) {
-			return;
-		}
-
-		const {test} = node;
-
-		if (!(
-			(test.type === 'UnaryExpression' && test.operator === '!')
-			|| (test.type === 'BinaryExpression' && (test.operator === '!=' || test.operator === '!=='))
-		)) {
-			return;
-		}
-
-		return {
-			node: test,
-			messageId: MESSAGE_ID,
-			/** @param {import('eslint').Rule.RuleFixer} fixer */
-			* fix(fixer) {
-				const {sourceCode} = context;
-				yield convertNegatedCondition(fixer, node, context);
-				yield swapConsequentAndAlternate(fixer, node, context);
-
-				if (
-					node.type !== 'ConditionalExpression'
-					|| test.type !== 'UnaryExpression'
-				) {
-					return;
-				}
-
-				yield fixSpaceAroundKeyword(fixer, node, context);
-
-				const {parent} = node;
-				const [firstToken, secondToken] = sourceCode.getFirstTokens(test, 2);
-				if (
-					(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
-					&& parent.argument === node
-					&& !isOnSameLine(firstToken, secondToken, context)
-					&& !isParenthesized(node, sourceCode)
-					&& !isParenthesized(test, sourceCode)
-				) {
-					yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
-					return;
-				}
-
-				const tokenBefore = sourceCode.getTokenBefore(node);
-				if (needsSemicolon(tokenBefore, context, secondToken.value)) {
-					yield fixer.insertTextBefore(node, ';');
-				}
-			},
-		};
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow negated conditions.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-negation-in-equality-check.js

@@ -1,99 +0,0 @@
-import {fixSpaceAroundKeyword, addParenthesizesToReturnOrThrowExpression} from './fix/index.js';
-import {needsSemicolon, isParenthesized, isOnSameLine} from './utils/index.js';
-
-const MESSAGE_ID_ERROR = 'no-negation-in-equality-check/error';
-const MESSAGE_ID_SUGGESTION = 'no-negation-in-equality-check/suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Negated expression is not allowed in equality check.',
-	[MESSAGE_ID_SUGGESTION]: 'Switch to \'{{operator}}\' check.',
-};
-
-const EQUALITY_OPERATORS = new Set([
-	'===',
-	'!==',
-	'==',
-	'!=',
-]);
-
-const isEqualityCheck = node => node.type === 'BinaryExpression' && EQUALITY_OPERATORS.has(node.operator);
-const isNegatedExpression = node => node.type === 'UnaryExpression' && node.prefix && node.operator === '!';
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	BinaryExpression(binaryExpression) {
-		const {operator, left} = binaryExpression;
-
-		if (!(
-			isEqualityCheck(binaryExpression)
-			&& isNegatedExpression(left)
-			&& !isNegatedExpression(left.argument)
-		)) {
-			return;
-		}
-
-		const {sourceCode} = context;
-		const bangToken = sourceCode.getFirstToken(left);
-		const negatedOperator = `${operator.startsWith('!') ? '=' : '!'}${operator.slice(1)}`;
-
-		return {
-			node: bangToken,
-			messageId: MESSAGE_ID_ERROR,
-			/** @param {import('eslint').Rule.RuleFixer} fixer */
-			suggest: [
-				{
-					messageId: MESSAGE_ID_SUGGESTION,
-					data: {
-						operator: negatedOperator,
-					},
-					/** @param {import('eslint').Rule.RuleFixer} fixer */
-					* fix(fixer) {
-						yield fixSpaceAroundKeyword(fixer, binaryExpression, context);
-
-						const tokenAfterBang = sourceCode.getTokenAfter(bangToken);
-
-						const {parent} = binaryExpression;
-						if (
-							(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
-							&& !isParenthesized(binaryExpression, sourceCode)
-						) {
-							const returnToken = sourceCode.getFirstToken(parent);
-							if (!isOnSameLine(returnToken, tokenAfterBang, context)) {
-								yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
-							}
-						}
-
-						yield fixer.remove(bangToken);
-
-						const previousToken = sourceCode.getTokenBefore(bangToken);
-						if (needsSemicolon(previousToken, context, tokenAfterBang.value)) {
-							yield fixer.insertTextAfter(bangToken, ';');
-						}
-
-						const operatorToken = sourceCode.getTokenAfter(
-							left,
-							token => token.type === 'Punctuator' && token.value === operator,
-						);
-						yield fixer.replaceText(operatorToken, negatedOperator);
-					},
-				},
-			],
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Disallow negated expression in equality check.',
-			recommended: 'unopinionated',
-		},
-
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-nested-ternary.js

@@ -1,60 +0,0 @@
-import {isParenthesized} from '@eslint-community/eslint-utils';
-
-const MESSAGE_ID_TOO_DEEP = 'too-deep';
-const MESSAGE_ID_SHOULD_PARENTHESIZED = 'should-parenthesized';
-const messages = {
-	[MESSAGE_ID_TOO_DEEP]: 'Do not nest ternary expressions.',
-	[MESSAGE_ID_SHOULD_PARENTHESIZED]: 'Nested ternary expression should be parenthesized.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	ConditionalExpression(node) {
-		if ([
-			node.test,
-			node.consequent,
-			node.alternate,
-		].some(node => node.type === 'ConditionalExpression')) {
-			return;
-		}
-
-		const {sourceCode} = context;
-		const ancestors = sourceCode.getAncestors(node).toReversed();
-		const nestLevel = ancestors.findIndex(node => node.type !== 'ConditionalExpression');
-
-		if (nestLevel === 1 && !isParenthesized(node, sourceCode)) {
-			return {
-				node,
-				messageId: MESSAGE_ID_SHOULD_PARENTHESIZED,
-				fix: fixer => [
-					fixer.insertTextBefore(node, '('),
-					fixer.insertTextAfter(node, ')'),
-				],
-			};
-		}
-
-		// Nesting more than one level not allowed
-		if (nestLevel > 1) {
-			return {
-				node: nestLevel > 2 ? ancestors[nestLevel - 3] : node,
-				messageId: MESSAGE_ID_TOO_DEEP,
-			};
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow nested ternary expressions.',
-			recommended: true,
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;