@alexlit/lint-kit 176.0.0 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-keyboard-event-key.js

@@ -1,188 +0,0 @@
-import escapeString from './utils/escape-string.js';
-import translateToKey from './shared/event-keys.js';
-import {isNumericLiteral} from './ast/index.js';
-
-const MESSAGE_ID = 'prefer-keyboard-event-key';
-const messages = {
-	[MESSAGE_ID]: 'Use `.key` instead of `.{{name}}`.',
-};
-
-const keys = new Set([
-	'keyCode',
-	'charCode',
-	'which',
-]);
-
-const isPropertyNamedAddEventListener = node =>
-	node?.type === 'CallExpression'
-	&& node.callee.type === 'MemberExpression'
-	&& node.callee.property.name === 'addEventListener';
-
-const getEventNodeAndReferences = (context, node) => {
-	const eventListener = getMatchingAncestorOfType(node, 'CallExpression', isPropertyNamedAddEventListener);
-	const callback = eventListener?.arguments[1];
-	switch (callback?.type) {
-		case 'ArrowFunctionExpression':
-		case 'FunctionExpression': {
-			const eventVariable = context.sourceCode.getDeclaredVariables(callback)[0];
-			const references = eventVariable?.references;
-			return {
-				event: callback.params[0],
-				references,
-			};
-		}
-
-		default: {
-			return {};
-		}
-	}
-};
-
-const isPropertyOf = (node, eventNode) =>
-	node?.parent?.type === 'MemberExpression'
-	&& node.parent.object === eventNode;
-
-// The third argument is a condition function, as one passed to `Array#filter()`
-// Helpful if nearest node of type also needs to have some other property
-const getMatchingAncestorOfType = (node, type, testFunction = () => true) => {
-	let current = node;
-	while (current) {
-		if (current.type === type && testFunction(current)) {
-			return current;
-		}
-
-		current = current.parent;
-	}
-};
-
-const getParentByLevel = (node, level) => {
-	let current = node;
-	while (current && level) {
-		level--;
-		current = current.parent;
-	}
-
-	/* c8 ignore next 3 */
-	if (level === 0) {
-		return current;
-	}
-};
-
-const fix = node => fixer => {
-	// Since we're only fixing direct property access usages, like `event.keyCode`
-	const nearestIf = getParentByLevel(node, 3);
-	if (!nearestIf || nearestIf.type !== 'IfStatement') {
-		return;
-	}
-
-	const {type, operator, right} = nearestIf.test;
-	if (
-		!(
-			type === 'BinaryExpression'
-			&& (operator === '==' || operator === '===')
-			&& isNumericLiteral(right)
-		)
-	) {
-		return;
-	}
-
-	// Either a meta key or a printable character
-	const key = translateToKey[right.value] || String.fromCodePoint(right.value);
-	// And if we recognize the `.keyCode`
-	if (!key) {
-		return;
-	}
-
-	// Apply fixes
-	return [
-		fixer.replaceText(node, 'key'),
-		fixer.replaceText(right, escapeString(key)),
-	];
-};
-
-const getProblem = node => ({
-	messageId: MESSAGE_ID,
-	data: {name: node.name},
-	node,
-	fix: fix(node),
-});
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	Identifier(node) {
-		if (
-			node.name !== 'keyCode'
-			&& node.name !== 'charCode'
-			&& node.name !== 'which'
-		) {
-			return;
-		}
-
-		// Normal case when usage is direct -> `event.keyCode`
-		const {event, references} = getEventNodeAndReferences(context, node);
-		if (!event) {
-			return;
-		}
-
-		if (
-			references
-			&& references.some(reference => isPropertyOf(node, reference.identifier))
-		) {
-			return getProblem(node);
-		}
-	},
-
-	Property(node) {
-		// Destructured case
-		const propertyName = node.value.name;
-		if (!keys.has(propertyName)) {
-			return;
-		}
-
-		const {event, references} = getEventNodeAndReferences(context, node);
-		if (!event) {
-			return;
-		}
-
-		const nearestVariableDeclarator = getMatchingAncestorOfType(
-			node,
-			'VariableDeclarator',
-		);
-		const initObject = nearestVariableDeclarator?.init;
-
-		// Make sure initObject is a reference of eventVariable
-		if (
-			references
-			&& references.some(reference => reference.identifier === initObject)
-		) {
-			return getProblem(node.value);
-		}
-
-		// When the event parameter itself is destructured directly
-		const isEventParameterDestructured = event.type === 'ObjectPattern';
-		if (isEventParameterDestructured) {
-			// Check for properties
-			for (const property of event.properties) {
-				if (property === node) {
-					return getProblem(node.value);
-				}
-			}
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-logical-operator-over-ternary.js

@@ -1,162 +0,0 @@
-import {isParenthesized, getParenthesizedText} from './utils/parentheses.js';
-import isSameReference from './utils/is-same-reference.js';
-import shouldAddParenthesesToLogicalExpressionChild from './utils/should-add-parentheses-to-logical-expression-child.js';
-import needsSemicolon from './utils/needs-semicolon.js';
-
-const MESSAGE_ID_ERROR = 'prefer-logical-operator-over-ternary/error';
-const MESSAGE_ID_SUGGESTION = 'prefer-logical-operator-over-ternary/suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Prefer using a logical operator over a ternary.',
-	[MESSAGE_ID_SUGGESTION]: 'Switch to `{{operator}}` operator.',
-};
-
-function isSameNode(left, right, sourceCode) {
-	if (isSameReference(left, right)) {
-		return true;
-	}
-
-	if (left.type !== right.type) {
-		return false;
-	}
-
-	switch (left.type) {
-		case 'AwaitExpression': {
-			return isSameNode(left.argument, right.argument, sourceCode);
-		}
-
-		case 'LogicalExpression': {
-			return (
-				left.operator === right.operator
-				&& isSameNode(left.left, right.left, sourceCode)
-				&& isSameNode(left.right, right.right, sourceCode)
-			);
-		}
-
-		case 'UnaryExpression': {
-			return (
-				left.operator === right.operator
-				&& left.prefix === right.prefix
-				&& isSameNode(left.argument, right.argument, sourceCode)
-			);
-		}
-
-		case 'UpdateExpression': {
-			return false;
-		}
-
-		// No default
-	}
-
-	return sourceCode.getText(left) === sourceCode.getText(right);
-}
-
-function fix({
-	fixer,
-	context,
-	conditionalExpression,
-	left,
-	right,
-	operator,
-}) {
-	const {sourceCode} = context;
-	let text = [left, right].map((node, index) => {
-		const isNodeParenthesized = isParenthesized(node, sourceCode);
-		let text = isNodeParenthesized ? getParenthesizedText(node, context) : sourceCode.getText(node);
-
-		if (
-			!isNodeParenthesized
-			&& shouldAddParenthesesToLogicalExpressionChild(node, {operator, property: index === 0 ? 'left' : 'right'})
-		) {
-			text = `(${text})`;
-		}
-
-		return text;
-	}).join(` ${operator} `);
-
-	// According to https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#table
-	// There should be no cases need add parentheses when switching ternary to logical expression
-
-	// ASI
-	if (needsSemicolon(sourceCode.getTokenBefore(conditionalExpression), context, text)) {
-		text = `;${text}`;
-	}
-
-	return fixer.replaceText(conditionalExpression, text);
-}
-
-function getProblem({
-	context,
-	conditionalExpression,
-	left,
-	right,
-}) {
-	return {
-		node: conditionalExpression,
-		messageId: MESSAGE_ID_ERROR,
-		suggest: ['??', '||'].map(operator => ({
-			messageId: MESSAGE_ID_SUGGESTION,
-			data: {operator},
-			fix: fixer => fix({
-				fixer,
-				context,
-				conditionalExpression,
-				left,
-				right,
-				operator,
-			}),
-		})),
-	};
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-
-	return {
-		ConditionalExpression(conditionalExpression) {
-			const {test, consequent, alternate} = conditionalExpression;
-
-			// `foo ? foo : bar`
-			if (isSameNode(test, consequent, sourceCode)) {
-				return getProblem({
-					context,
-					conditionalExpression,
-					left: test,
-					right: alternate,
-				});
-			}
-
-			// `!bar ? foo : bar`
-			if (
-				test.type === 'UnaryExpression'
-				&& test.operator === '!'
-				&& test.prefix
-				&& isSameNode(test.argument, alternate, sourceCode)
-			) {
-				return getProblem({
-					context,
-					conditionalExpression,
-					left: test.argument,
-					right: consequent,
-				});
-			}
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer using a logical operator over a ternary.',
-			recommended: 'unopinionated',
-		},
-
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-math-min-max.js

@@ -1,205 +0,0 @@
-/* eslint-disable complexity */
-import {isBigIntLiteral, isCallExpression} from './ast/index.js';
-import {fixSpaceAroundKeyword} from './fix/index.js';
-
-const MESSAGE_ID = 'prefer-math-min-max';
-const messages = {
-	[MESSAGE_ID]: 'Prefer `Math.{{method}}()` to simplify ternary expressions.',
-};
-
-const isNumberTypeAnnotation = typeAnnotation => {
-	if (typeAnnotation.type === 'TSNumberKeyword') {
-		return true;
-	}
-
-	if (typeAnnotation.type === 'TSTypeAnnotation' && typeAnnotation.typeAnnotation.type === 'TSNumberKeyword') {
-		return true;
-	}
-
-	if (typeAnnotation.type === 'TSTypeReference' && typeAnnotation.typeName.name === 'Number') {
-		return true;
-	}
-
-	return false;
-};
-
-const getExpressionText = (node, sourceCode) => {
-	const expressionNode = node.type === 'TSAsExpression' ? node.expression : node;
-
-	if (node.type === 'TSAsExpression') {
-		return getExpressionText(expressionNode, sourceCode);
-	}
-
-	return sourceCode.getText(expressionNode);
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	/** @param {import('estree').ConditionalExpression} conditionalExpression */
-	ConditionalExpression(conditionalExpression) {
-		const {test, consequent, alternate} = conditionalExpression;
-
-		if (test.type !== 'BinaryExpression') {
-			return;
-		}
-
-		const {operator, left, right} = test;
-
-		const hasBigInt = [left, right].some(
-			node =>
-				isBigIntLiteral(node)
-				|| isCallExpression(node, {
-					name: 'BigInt',
-					argumentsLength: 1,
-					optional: false,
-				}),
-		);
-
-		if (hasBigInt) {
-			return;
-		}
-
-		const [leftText, rightText, alternateText, consequentText] = [left, right, alternate, consequent].map(node => getExpressionText(node, context.sourceCode));
-
-		const isGreaterOrEqual = operator === '>' || operator === '>=';
-		const isLessOrEqual = operator === '<' || operator === '<=';
-
-		let method;
-
-		// Prefer `Math.min()`
-		if (
-			// `height > 50 ? 50 : height`
-			(isGreaterOrEqual && leftText === alternateText && rightText === consequentText)
-			// `height < 50 ? height : 50`
-			|| (isLessOrEqual && leftText === consequentText && rightText === alternateText)
-		) {
-			method = 'min';
-		} else if (
-			// `height > 50 ? height : 50`
-			(isGreaterOrEqual && leftText === consequentText && rightText === alternateText)
-			// `height < 50 ? 50 : height`
-			|| (isLessOrEqual && leftText === alternateText && rightText === consequentText)
-		) {
-			method = 'max';
-		}
-
-		if (!method) {
-			return;
-		}
-
-		for (const node of [left, right]) {
-			let expressionNode = node;
-
-			if (expressionNode.typeAnnotation && expressionNode.type === 'TSAsExpression') {
-				// Ignore if the test is not a number comparison operator
-				if (!isNumberTypeAnnotation(expressionNode.typeAnnotation)) {
-					return;
-				}
-
-				expressionNode = expressionNode.expression;
-			}
-
-			// Find variable declaration
-			if (expressionNode.type === 'Identifier') {
-				const variable = context.sourceCode.getScope(expressionNode).variables.find(variable => variable.name === expressionNode.name);
-
-				for (const definition of variable?.defs ?? []) {
-					switch (definition.type) {
-						case 'Parameter': {
-							const identifier = definition.name;
-
-							/**
-							Capture the following statement
-
-							```js
-							function foo(a: number) {}
-							```
-							*/
-							if (identifier.typeAnnotation?.type === 'TSTypeAnnotation' && !isNumberTypeAnnotation(identifier.typeAnnotation)) {
-								return;
-							}
-
-							/**
-							Capture the following statement
-
-							```js
-							function foo(a = 10) {}
-							```
-							*/
-							if (identifier.parent.type === 'AssignmentPattern' && identifier.parent.right.type === 'Literal' && typeof identifier.parent.right.value !== 'number') {
-								return;
-							}
-
-							break;
-						}
-
-						case 'Variable': {
-							/** @type {import('estree').VariableDeclarator}  */
-							const variableDeclarator = definition.node;
-
-							/**
-							Capture the following statement
-
-							```js
-							var foo: number
-							```
-							*/
-							if (variableDeclarator.id.typeAnnotation?.type === 'TSTypeAnnotation' && !isNumberTypeAnnotation(variableDeclarator.id.typeAnnotation)) {
-								return;
-							}
-
-							/**
-							Capture the following statement
-
-							```js
-							var foo = 10
-							```
-							*/
-							if (variableDeclarator.init?.type === 'Literal' && typeof variableDeclarator.init.value !== 'number') {
-								return;
-							}
-
-							break;
-						}
-
-						default:
-					}
-				}
-			}
-		}
-
-		return {
-			node: conditionalExpression,
-			messageId: MESSAGE_ID,
-			data: {method},
-			/** @param {import('eslint').Rule.RuleFixer} fixer */
-			* fix(fixer) {
-				const {sourceCode} = context;
-
-				yield fixSpaceAroundKeyword(fixer, conditionalExpression, context);
-
-				const argumentsText = [left, right]
-					.map(node => node.type === 'SequenceExpression' ? `(${sourceCode.getText(node)})` : sourceCode.getText(node))
-					.join(', ');
-
-				yield fixer.replaceText(conditionalExpression, `Math.${method}(${argumentsText})`);
-			},
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Prefer `Math.min()` and `Math.max()` over ternaries for simple comparisons.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-math-trunc.js

@@ -1,111 +0,0 @@
-import {hasSideEffect} from '@eslint-community/eslint-utils';
-import {fixSpaceAroundKeyword} from './fix/index.js';
-import {isLiteral} from './ast/index.js';
-
-const ERROR_BITWISE = 'error-bitwise';
-const ERROR_BITWISE_NOT = 'error-bitwise-not';
-const SUGGESTION_BITWISE = 'suggestion-bitwise';
-const messages = {
-	[ERROR_BITWISE]: 'Use `Math.trunc` instead of `{{operator}} {{value}}`.',
-	[ERROR_BITWISE_NOT]: 'Use `Math.trunc` instead of `~~`.',
-	[SUGGESTION_BITWISE]: 'Replace `{{operator}} {{value}}` with `Math.trunc`.',
-};
-
-// Bitwise operators
-const bitwiseOperators = new Set(['|', '>>', '<<', '^']);
-const isBitwiseNot = node =>
-	node.type === 'UnaryExpression'
-	&& node.operator === '~';
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-
-	const mathTruncFunctionCall = node => {
-		const text = sourceCode.getText(node);
-		const parenthesized = node.type === 'SequenceExpression' ? `(${text})` : text;
-		return `Math.trunc(${parenthesized})`;
-	};
-
-	context.on(['BinaryExpression', 'AssignmentExpression'], node => {
-		const {type, operator, right, left} = node;
-		const isAssignment = type === 'AssignmentExpression';
-		if (
-			!isLiteral(right, 0)
-			|| !bitwiseOperators.has(isAssignment ? operator.slice(0, -1) : operator)
-		) {
-			return;
-		}
-
-		const problem = {
-			node,
-			messageId: ERROR_BITWISE,
-			data: {
-				operator,
-				value: right.raw,
-			},
-		};
-
-		if (!isAssignment || !hasSideEffect(left, sourceCode)) {
-			const fix = function * (fixer) {
-				const fixed = mathTruncFunctionCall(left);
-				if (isAssignment) {
-					const operatorToken = sourceCode.getTokenAfter(left, token => token.type === 'Punctuator' && token.value === operator);
-					yield fixer.replaceText(operatorToken, '=');
-					yield fixer.replaceText(right, fixed);
-				} else {
-					yield fixSpaceAroundKeyword(fixer, node, context);
-					yield fixer.replaceText(node, fixed);
-				}
-			};
-
-			if (operator === '|') {
-				problem.suggest = [
-					{
-						messageId: SUGGESTION_BITWISE,
-						fix,
-					},
-				];
-			} else {
-				problem.fix = fix;
-			}
-		}
-
-		return problem;
-	});
-
-	// Unary Expression Selector: Inner-most 2 bitwise NOT
-	context.on('UnaryExpression', node => {
-		if (
-			isBitwiseNot(node)
-			&& isBitwiseNot(node.argument)
-			&& !isBitwiseNot(node.argument.argument)
-		) {
-			return {
-				node,
-				messageId: ERROR_BITWISE_NOT,
-				* fix(fixer) {
-					yield fixer.replaceText(node, mathTruncFunctionCall(node.argument.argument));
-					yield fixSpaceAroundKeyword(fixer, node, context);
-				},
-			};
-		}
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Enforce the use of `Math.trunc` instead of bitwise operators.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;