@alexlit/lint-kit 175.0.0 → 176.0.1

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

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

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

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

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