@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-classlist-toggle.js

@@ -1,255 +0,0 @@
-import {
-	isMethodCall,
-	isMemberExpression,
-	isStringLiteral,
-	isCallExpression,
-	isExpressionStatement,
-} from './ast/index.js';
-import {
-	replaceMemberExpressionProperty,
-	fixSpaceAroundKeyword,
-} from './fix/index.js';
-import {
-	isSameReference,
-	isParenthesized,
-	getParenthesizedText,
-	shouldAddParenthesesToUnaryExpressionArgument,
-	needsSemicolon,
-} from './utils/index.js';
-
-const MESSAGE_ID_ERROR = 'prefer-classlist-toggle/error';
-const MESSAGE_ID_SUGGESTION = 'prefer-classlist-toggle/suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Prefer using `Element#classList.toggle()` to toggle class names.',
-	[MESSAGE_ID_SUGGESTION]: 'Replace with `Element#classList.toggle()`.',
-};
-
-const isClassList = node => isMemberExpression(node, {
-	property: 'classList',
-	computed: false,
-});
-
-const getProblem = (valueNode, fix, reportNode) => {
-	const problem = {
-		node: reportNode ?? valueNode,
-		messageId: MESSAGE_ID_ERROR,
-	};
-
-	const shouldUseSuggestion = valueNode.type !== 'IfStatement'
-		&& !(isExpressionStatement(valueNode) || isExpressionStatement(valueNode.parent));
-
-	if (shouldUseSuggestion) {
-		problem.suggest = [
-			{
-				messageId: MESSAGE_ID_SUGGESTION,
-				fix,
-			},
-		];
-	} else {
-		problem.fix = fix;
-	}
-
-	return problem;
-};
-
-const getConditionText = (node, context, isNegative) => {
-	const {sourceCode} = context;
-	let text = getParenthesizedText(node, context);
-
-	if (isNegative) {
-		if (
-			!isParenthesized(node, sourceCode)
-			&& shouldAddParenthesesToUnaryExpressionArgument(node, '!')
-		) {
-			text = `(${text})`;
-		}
-
-		text = `!${text}`;
-		return text;
-	}
-
-	if (
-		!isParenthesized(node, sourceCode)
-		&& node.type === 'SequenceExpression'
-	) {
-		text = `(${text})`;
-	}
-
-	return text;
-};
-
-const isClassListMethodCall = (node, methods) =>
-	isMethodCall(node, {
-		methods,
-		argumentsLength: 1,
-		optionalCall: false,
-		optionalMember: false,
-	})
-	&& isClassList(node.callee.object);
-
-const isSameElementAndClassName = (callExpressionA, callExpressionB) =>
-	isSameReference(callExpressionA.callee.object, callExpressionB.callee.object)
-	&& isSameReference(callExpressionA.arguments[0], callExpressionB.arguments[0]);
-
-const getClassListContainsCall = (conditionNode, isNegative, addOrRemoveCall) => {
-	if (!isNegative) {
-		if (conditionNode.type === 'UnaryExpression' && conditionNode.operator === '!' && conditionNode.prefix) {
-			return getClassListContainsCall(conditionNode.argument, !isNegative, addOrRemoveCall);
-		}
-
-		return;
-	}
-
-	if (conditionNode.type === 'ChainExpression') {
-		conditionNode = conditionNode.expression;
-	}
-
-	if (
-		isClassListMethodCall(conditionNode, ['contains'])
-		&& isSameElementAndClassName(conditionNode, addOrRemoveCall)
-	) {
-		return conditionNode;
-	}
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-
-	/*
-	```js
-	if (condition) {
-		element.classList.add('className');
-	} else {
-		element.classList.remove('className');
-	}
-	```
-
-	```js
-	condition
-		? element.classList.add('className');
-		: element.classList.remove('className');
-	```
-	*/
-	context.on(['IfStatement', 'ConditionalExpression'], node => {
-		const clauses = [node.consequent, node.alternate]
-			.map(node => {
-				if (!node) {
-					return;
-				}
-
-				if (node.type === 'BlockStatement' && node.body.length === 1) {
-					node = node.body[0];
-				}
-
-				if (node.type === 'ExpressionStatement') {
-					node = node.expression;
-				}
-
-				if (node.type === 'ChainExpression') {
-					node = node.expression;
-				}
-
-				return node;
-			});
-
-		// `element.classList.add('className');`
-		// `element.classList.remove('className');`
-		if (!clauses.every(node => isClassListMethodCall(node, ['add', 'remove']))) {
-			return;
-		}
-
-		const [consequent, alternate] = clauses;
-		if (
-			(consequent.callee.property.name === alternate.callee.property.name)
-			|| !isSameElementAndClassName(consequent, alternate)
-		) {
-			return;
-		}
-
-		/** @param {import('eslint').Rule.RuleFixer} fixer */
-		function * fix(fixer) {
-			const elementText = getParenthesizedText(consequent.callee.object.object, context);
-			const classNameText = getParenthesizedText(consequent.arguments[0], context);
-			const isExpression = node.type === 'ConditionalExpression';
-			const isNegative = consequent.callee.property.name === 'remove';
-			const conditionNode = node.test;
-			const classListContainsCall = getClassListContainsCall(conditionNode, isNegative, consequent);
-			const conditionText = classListContainsCall ? '' : getConditionText(conditionNode, context, isNegative);
-			const isOptional = consequent.callee.object.optional || alternate.callee.object.optional || classListContainsCall?.callee.object.optional;
-
-			let text = `${elementText}${isOptional ? '?' : ''}.classList.toggle(${classNameText}${conditionText ? `, ${conditionText}` : ''})`;
-
-			if (!isExpression) {
-				text = `${text};`;
-			}
-
-			if (needsSemicolon(sourceCode.getTokenBefore(node), context, text)) {
-				text = `;${text}`;
-			}
-
-			yield fixer.replaceText(node, text);
-
-			if (isExpression) {
-				yield fixSpaceAroundKeyword(fixer, node, context);
-			}
-		}
-
-		return getProblem(node, fix);
-	});
-
-	// `element.classList[condition ? 'add' : 'remove']('className')`
-	context.on('ConditionalExpression', conditionalExpression => {
-		const clauses = [conditionalExpression.consequent, conditionalExpression.alternate];
-
-		if (!(
-			clauses.every(node => isStringLiteral(node) && (node.value === 'add' || node.value === 'remove'))
-			&& clauses[0].value !== clauses[1].value
-			&& conditionalExpression.parent.type === 'MemberExpression'
-			&& conditionalExpression.parent.computed
-			&& !conditionalExpression.parent.optional
-			&& conditionalExpression.parent.property === conditionalExpression
-			&& isClassList(conditionalExpression.parent.object)
-			&& isCallExpression(conditionalExpression.parent.parent, {optional: false, argumentsLength: 1})
-			&& conditionalExpression.parent.parent.callee === conditionalExpression.parent
-		)) {
-			return;
-		}
-
-		const classListMethod = conditionalExpression.parent;
-		const callExpression = classListMethod.parent;
-
-		/** @param {import('eslint').Rule.RuleFixer} fixer */
-		function * fix(fixer) {
-			const isNegative = conditionalExpression.consequent.value === 'remove';
-			const conditionNode = conditionalExpression.test;
-			const classListContainsCall = getClassListContainsCall(conditionNode, isNegative, callExpression);
-			const conditionText = classListContainsCall ? '' : getConditionText(conditionNode, context, isNegative);
-
-			if (conditionText) {
-				yield fixer.insertTextAfter(callExpression.arguments[0], `, ${conditionText}`);
-			}
-
-			yield replaceMemberExpressionProperty(fixer, classListMethod, context, '.toggle');
-		}
-
-		return getProblem(callExpression, fix, conditionalExpression);
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer using `Element#classList.toggle()` to toggle class names.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-code-point.js

@@ -1,56 +0,0 @@
-import {isMemberExpression, isMethodCall} from './ast/index.js';
-
-const messages = {
-	'error/charCodeAt': 'Prefer `String#codePointAt()` over `String#charCodeAt()`.',
-	'error/fromCharCode': 'Prefer `String.fromCodePoint()` over `String.fromCharCode()`.',
-	'suggestion/codePointAt': 'Use `String#codePointAt()`.',
-	'suggestion/fromCodePoint': 'Use `String.fromCodePoint()`.',
-};
-
-const getProblem = (node, replacement) => ({
-	node,
-	messageId: `error/${node.name}`,
-	suggest: [
-		{
-			messageId: `suggestion/${replacement}`,
-			fix: fixer => fixer.replaceText(node, replacement),
-		},
-	],
-});
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = () => ({
-	CallExpression(node) {
-		if (isMethodCall(node, {
-			method: 'charCodeAt',
-			optionalCall: false,
-		})) {
-			return getProblem(node.callee.property, 'codePointAt');
-		}
-	},
-	MemberExpression(node) {
-		if (isMemberExpression(node, {
-			object: 'String',
-			property: 'fromCharCode',
-			optional: false,
-		})) {
-			return getProblem(node.property, 'fromCodePoint');
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `String#codePointAt(…)` over `String#charCodeAt(…)` and `String.fromCodePoint(…)` over `String.fromCharCode(…)`.',
-			recommended: 'unopinionated',
-		},
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-date-now.js

@@ -1,133 +0,0 @@
-import {isMethodCall, isCallExpression, isNewExpression} from './ast/index.js';
-import {fixSpaceAroundKeyword} from './fix/index.js';
-
-const MESSAGE_ID_DEFAULT = 'prefer-date';
-const MESSAGE_ID_METHOD = 'prefer-date-now-over-methods';
-const MESSAGE_ID_NUMBER = 'prefer-date-now-over-number-data-object';
-const messages = {
-	[MESSAGE_ID_DEFAULT]: 'Prefer `Date.now()` over `new Date()`.',
-	[MESSAGE_ID_METHOD]: 'Prefer `Date.now()` over `Date#{{method}}()`.',
-	[MESSAGE_ID_NUMBER]: 'Prefer `Date.now()` over `Number(new Date())`.',
-};
-
-const isNewDate = node => isNewExpression(node, {name: 'Date', argumentsLength: 0});
-
-const getProblem = (node, problem, context) => ({
-	node,
-	messageId: MESSAGE_ID_DEFAULT,
-	* fix(fixer) {
-		yield fixer.replaceText(node, 'Date.now()');
-
-		if (node.type === 'UnaryExpression') {
-			yield fixSpaceAroundKeyword(fixer, node, context);
-		}
-	},
-	...problem,
-});
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	CallExpression(callExpression) {
-		// `new Date().{getTime,valueOf}()`
-		if (
-			isMethodCall(callExpression, {
-				methods: ['getTime', 'valueOf'],
-				argumentsLength: 0,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& isNewDate(callExpression.callee.object)
-		) {
-			const method = callExpression.callee.property;
-			return getProblem(callExpression, {
-				node: method,
-				messageId: MESSAGE_ID_METHOD,
-				data: {method: method.name},
-			});
-		}
-
-		// `{Number,BigInt}(new Date())`
-		if (
-			isCallExpression(callExpression, {
-				names: ['Number', 'BigInt'],
-				argumentsLength: 1,
-				optional: false,
-			})
-			&& isNewDate(callExpression.arguments[0])
-		) {
-			const {name} = callExpression.callee;
-			if (name === 'Number') {
-				return getProblem(callExpression, {
-					messageId: MESSAGE_ID_NUMBER,
-				});
-			}
-
-			return getProblem(callExpression.arguments[0]);
-		}
-	},
-	UnaryExpression(unaryExpression) {
-		// https://github.com/estree/estree/blob/master/es5.md#unaryoperator
-		if (
-			unaryExpression.operator !== '+'
-			&& unaryExpression.operator !== '-'
-		) {
-			return;
-		}
-
-		if (isNewDate(unaryExpression.argument)) {
-			return getProblem(
-				unaryExpression.operator === '-' ? unaryExpression.argument : unaryExpression,
-				{},
-				context,
-			);
-		}
-	},
-	AssignmentExpression(assignmentExpression) {
-		if (
-			assignmentExpression.operator !== '-='
-			&& assignmentExpression.operator !== '*='
-			&& assignmentExpression.operator !== '/='
-			&& assignmentExpression.operator !== '%='
-			&& assignmentExpression.operator !== '**='
-		) {
-			return;
-		}
-
-		if (isNewDate(assignmentExpression.right)) {
-			return getProblem(assignmentExpression.right);
-		}
-	},
-	* BinaryExpression(binaryExpression) {
-		if (
-			binaryExpression.operator !== '-'
-			&& binaryExpression.operator !== '*'
-			&& binaryExpression.operator !== '/'
-			&& binaryExpression.operator !== '%'
-			&& binaryExpression.operator !== '**'
-		) {
-			return;
-		}
-
-		for (const node of [binaryExpression.left, binaryExpression.right]) {
-			if (isNewDate(node)) {
-				yield getProblem(node);
-			}
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `Date.now()` to get the number of milliseconds since the Unix Epoch.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-default-parameters.js

@@ -1,218 +0,0 @@
-import {findVariable} from '@eslint-community/eslint-utils';
-import {functionTypes} from './ast/index.js';
-
-const MESSAGE_ID = 'preferDefaultParameters';
-const MESSAGE_ID_SUGGEST = 'preferDefaultParametersSuggest';
-
-const isDefaultExpression = (left, right) =>
-	left
-	&& right
-	&& left.type === 'Identifier'
-	&& right.type === 'LogicalExpression'
-	&& (right.operator === '||' || right.operator === '??')
-	&& right.left.type === 'Identifier'
-	&& right.right.type === 'Literal';
-
-const containsCallExpression = (sourceCode, node) => {
-	if (!node) {
-		return false;
-	}
-
-	if (node.type === 'CallExpression') {
-		return true;
-	}
-
-	const keys = sourceCode.visitorKeys[node.type];
-
-	for (const key of keys) {
-		const value = node[key];
-
-		if (Array.isArray(value)) {
-			for (const element of value) {
-				if (containsCallExpression(sourceCode, element)) {
-					return true;
-				}
-			}
-		} else if (containsCallExpression(sourceCode, value)) {
-			return true;
-		}
-	}
-
-	return false;
-};
-
-const hasSideEffects = (sourceCode, function_, node) => {
-	for (const element of function_.body.body) {
-		if (element === node) {
-			break;
-		}
-
-		// Function call before default-assignment
-		if (containsCallExpression(sourceCode, element)) {
-			return true;
-		}
-	}
-
-	return false;
-};
-
-const hasExtraReferences = (assignment, references, left) => {
-	// Parameter is referenced prior to default-assignment
-	if (assignment && references[0].identifier !== left) {
-		return true;
-	}
-
-	// Old parameter is still referenced somewhere else
-	if (!assignment && references.length > 1) {
-		return true;
-	}
-
-	return false;
-};
-
-const isLastParameter = (parameters, parameter) => {
-	const lastParameter = parameters.at(-1);
-
-	// See 'default-param-last' rule
-	return parameter && parameter === lastParameter;
-};
-
-const needsParentheses = (sourceCode, function_) => {
-	if (function_.type !== 'ArrowFunctionExpression' || function_.params.length > 1) {
-		return false;
-	}
-
-	const [parameter] = function_.params;
-	const before = sourceCode.getTokenBefore(parameter);
-	const after = sourceCode.getTokenAfter(parameter);
-
-	return !after || !before || before.value !== '(' || after.value !== ')';
-};
-
-/** @param {import('eslint').Rule.RuleFixer} fixer */
-const fixDefaultExpression = (fixer, sourceCode, node) => {
-	const {line} = sourceCode.getLoc(node).start;
-	const {column} = sourceCode.getLoc(node).end;
-	const nodeText = sourceCode.getText(node);
-	const lineText = sourceCode.lines[line - 1];
-	const isOnlyNodeOnLine = lineText.trim() === nodeText;
-	const endsWithWhitespace = lineText[column] === ' ';
-
-	if (isOnlyNodeOnLine) {
-		return fixer.removeRange([
-			sourceCode.getIndexFromLoc({line, column: 0}),
-			sourceCode.getIndexFromLoc({line: line + 1, column: 0}),
-		]);
-	}
-
-	if (endsWithWhitespace) {
-		const [start, end] = sourceCode.getRange(node);
-		return fixer.removeRange([start, end + 1]);
-	}
-
-	return fixer.remove(node);
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-	const functionStack = [];
-
-	const checkExpression = (node, left, right, assignment) => {
-		const currentFunction = functionStack.at(-1);
-
-		if (!currentFunction || !isDefaultExpression(left, right)) {
-			return;
-		}
-
-		const {name: firstId} = left;
-		const {
-			left: {name: secondId},
-			right: {raw: literal},
-		} = right;
-
-		// Parameter is reassigned to a different identifier
-		if (assignment && firstId !== secondId) {
-			return;
-		}
-
-		const variable = findVariable(sourceCode.getScope(node), secondId);
-
-		// This was reported https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1122
-		// But can't reproduce, just ignore this case
-		/* c8 ignore next 3 */
-		if (!variable) {
-			return;
-		}
-
-		const {references} = variable;
-		const {params} = currentFunction;
-		const parameter = params.find(parameter =>
-			parameter.type === 'Identifier'
-			&& parameter.name === secondId,
-		);
-
-		if (
-			hasSideEffects(sourceCode, currentFunction, node)
-			|| hasExtraReferences(assignment, references, left)
-			|| !isLastParameter(params, parameter)
-		) {
-			return;
-		}
-
-		const replacement = needsParentheses(sourceCode, currentFunction)
-			? `(${firstId} = ${literal})`
-			: `${firstId} = ${literal}`;
-
-		return {
-			node,
-			messageId: MESSAGE_ID,
-			suggest: [{
-				messageId: MESSAGE_ID_SUGGEST,
-				fix: fixer => [
-					fixer.replaceText(parameter, replacement),
-					fixDefaultExpression(fixer, sourceCode, node),
-				],
-			}],
-		};
-	};
-
-	context.on(functionTypes, node => {
-		functionStack.push(node);
-	});
-
-	context.onExit(functionTypes, () => {
-		functionStack.pop();
-	});
-
-	context.on('AssignmentExpression', node => {
-		if (node.parent.type === 'ExpressionStatement' && node.parent.expression === node) {
-			return checkExpression(node.parent, node.left, node.right, true);
-		}
-	});
-
-	context.on('VariableDeclarator', node => {
-		if (node.parent.type === 'VariableDeclaration' && node.parent.declarations[0] === node) {
-			return checkExpression(node.parent, node.id, node.init, false);
-		}
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer default parameters over reassignment.',
-			recommended: 'unopinionated',
-		},
-		hasSuggestions: true,
-		messages: {
-			[MESSAGE_ID]: 'Prefer default parameters over reassignment.',
-			[MESSAGE_ID_SUGGEST]: 'Replace reassignment with default parameter.',
-		},
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-dom-node-append.js

@@ -1,50 +0,0 @@
-import {isMethodCall} from './ast/index.js';
-import {isNodeValueNotDomNode, isValueNotUsable} from './utils/index.js';
-
-const MESSAGE_ID = 'prefer-dom-node-append';
-const messages = {
-	[MESSAGE_ID]: 'Prefer `Node#append()` over `Node#appendChild()`.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = () => ({
-	CallExpression(node) {
-		if (
-			!isMethodCall(node, {
-				method: 'appendChild',
-				argumentsLength: 1,
-				optionalCall: false,
-			})
-			|| isNodeValueNotDomNode(node.callee.object)
-			|| isNodeValueNotDomNode(node.arguments[0])
-		) {
-			return;
-		}
-
-		const fix = isValueNotUsable(node)
-			? fixer => fixer.replaceText(node.callee.property, 'append')
-			: undefined;
-
-		return {
-			node,
-			messageId: MESSAGE_ID,
-			fix,
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `Node#append()` over `Node#appendChild()`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;