@alexlit/lint-kit 175.0.0 → 176.0.0

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

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

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

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

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

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