@alexlit/lint-kit 175.0.0 → 176.0.0

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

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

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

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

@@ -0,0 +1,145 @@
+/*
+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

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

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