@alexlit/lint-kit 174.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-optional-catch-binding.js

@@ -0,0 +1,77 @@
+import {isOpeningParenToken, isClosingParenToken} from '@eslint-community/eslint-utils';
+import assertToken from './utils/assert-token.js';
+
+const MESSAGE_ID_WITH_NAME = 'with-name';
+const MESSAGE_ID_WITHOUT_NAME = 'without-name';
+const messages = {
+	[MESSAGE_ID_WITH_NAME]: 'Remove unused catch binding `{{name}}`.',
+	[MESSAGE_ID_WITHOUT_NAME]: 'Remove unused catch binding.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CatchClause(catchClause) {
+		const node = catchClause.param;
+		if (!node) {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const variables = sourceCode.getDeclaredVariables(node.parent);
+
+		if (variables.some(variable => variable.references.length > 0)) {
+			return;
+		}
+
+		const {type, name, parent} = node;
+
+		return {
+			node,
+			messageId: type === 'Identifier' ? MESSAGE_ID_WITH_NAME : MESSAGE_ID_WITHOUT_NAME,
+			data: {name},
+			* fix(fixer) {
+				const tokenBefore = sourceCode.getTokenBefore(node);
+				assertToken(tokenBefore, {
+					test: isOpeningParenToken,
+					expected: '(',
+					ruleId: 'prefer-optional-catch-binding',
+				});
+
+				const tokenAfter = sourceCode.getTokenAfter(node);
+				assertToken(tokenAfter, {
+					test: isClosingParenToken,
+					expected: ')',
+					ruleId: 'prefer-optional-catch-binding',
+				});
+
+				yield fixer.remove(tokenBefore);
+				yield fixer.remove(node);
+				yield fixer.remove(tokenAfter);
+
+				const [, endOfClosingParenthesis] = sourceCode.getRange(tokenAfter);
+				const [startOfCatchClauseBody] = sourceCode.getRange(parent.body);
+				const text = sourceCode.text.slice(endOfClosingParenthesis, startOfCatchClauseBody);
+				const leadingSpacesLength = text.length - text.trimStart().length;
+				if (leadingSpacesLength !== 0) {
+					yield fixer.removeRange([endOfClosingParenthesis, endOfClosingParenthesis + leadingSpacesLength]);
+				}
+			},
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer omitting the `catch` binding parameter.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-prototype-methods.js

@@ -0,0 +1,162 @@
+import {getPropertyName, ReferenceTracker} from '@eslint-community/eslint-utils';
+import {fixSpaceAroundKeyword} from './fix/index.js';
+import {isMemberExpression, isMethodCall} from './ast/index.js';
+
+const messages = {
+	'known-method': 'Prefer using `{{constructorName}}.prototype.{{methodName}}`.',
+	'unknown-method': 'Prefer using method from `{{constructorName}}.prototype`.',
+};
+
+const OBJECT_PROTOTYPE_METHODS = [
+	'hasOwnProperty',
+	'isPrototypeOf',
+	'propertyIsEnumerable',
+	'toLocaleString',
+	'toString',
+	'valueOf',
+];
+
+function getConstructorAndMethodName(methodNode, {context, globalReferences}) {
+	if (!methodNode) {
+		return;
+	}
+
+	const isGlobalReference = globalReferences.has(methodNode);
+	if (isGlobalReference) {
+		const path = globalReferences.get(methodNode);
+		return {
+			isGlobalReference: true,
+			constructorName: 'Object',
+			methodName: path.at(-1),
+		};
+	}
+
+	if (!isMemberExpression(methodNode, {optional: false})) {
+		return;
+	}
+
+	const objectNode = methodNode.object;
+
+	if (!(
+		(objectNode.type === 'ArrayExpression' && objectNode.elements.length === 0)
+		|| (objectNode.type === 'ObjectExpression' && objectNode.properties.length === 0)
+	)) {
+		return;
+	}
+
+	const constructorName = objectNode.type === 'ArrayExpression' ? 'Array' : 'Object';
+	const methodName = getPropertyName(methodNode, context.sourceCode.getScope(methodNode));
+
+	return {
+		constructorName,
+		methodName,
+	};
+}
+
+function getProblem(callExpression, {context, globalReferences}) {
+	let methodNode;
+
+	if (
+		// `Reflect.apply([].foo, …)`
+		// `Reflect.apply({}.foo, …)`
+		isMethodCall(callExpression, {
+			object: 'Reflect',
+			method: 'apply',
+			minimumArguments: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})
+	) {
+		methodNode = callExpression.arguments[0];
+	} else if (
+		// `[].foo.{apply,bind,call}(…)`
+		// `({}).foo.{apply,bind,call}(…)`
+		isMethodCall(callExpression, {
+			methods: ['apply', 'bind', 'call'],
+			optionalCall: false,
+			optionalMember: false,
+		})
+	) {
+		methodNode = callExpression.callee.object;
+	}
+
+	const {
+		isGlobalReference,
+		constructorName,
+		methodName,
+	} = getConstructorAndMethodName(methodNode, {context, globalReferences}) ?? {};
+
+	if (!constructorName) {
+		return;
+	}
+
+	return {
+		node: methodNode,
+		messageId: methodName ? 'known-method' : 'unknown-method',
+		data: {constructorName, methodName},
+		* fix(fixer) {
+			if (isGlobalReference) {
+				yield fixer.replaceText(methodNode, `${constructorName}.prototype.${methodName}`);
+				return;
+			}
+
+			if (isMemberExpression(methodNode)) {
+				const objectNode = methodNode.object;
+
+				yield fixer.replaceText(objectNode, `${constructorName}.prototype`);
+
+				if (
+					objectNode.type === 'ArrayExpression'
+					|| objectNode.type === 'ObjectExpression'
+				) {
+					yield fixSpaceAroundKeyword(fixer, callExpression, context);
+				}
+			}
+		},
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+function create(context) {
+	const {sourceCode} = context;
+	const callExpressions = [];
+
+	context.on('CallExpression', callExpression => {
+		callExpressions.push(callExpression);
+	});
+
+	context.onExit('Program', function * (program) {
+		const globalReferences = new WeakMap();
+
+		const tracker = new ReferenceTracker(sourceCode.getScope(program));
+
+		for (const {node, path} of tracker.iterateGlobalReferences(
+			Object.fromEntries(OBJECT_PROTOTYPE_METHODS.map(method => [method, {[ReferenceTracker.READ]: true}])),
+		)) {
+			globalReferences.set(node, path);
+		}
+
+		for (const callExpression of callExpressions) {
+			yield getProblem(callExpression, {
+				context,
+				globalReferences,
+			});
+		}
+	});
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer borrowing methods from the prototype instead of the instance.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-query-selector.js

@@ -0,0 +1,170 @@
+import {isNodeValueNotDomNode} from './utils/index.js';
+import {isMethodCall, isStringLiteral, isNullLiteral} from './ast/index.js';
+
+const MESSAGE_ID = 'prefer-query-selector';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `.{{replacement}}()` over `.{{method}}()`.',
+};
+
+const disallowedIdentifierNames = new Map([
+	['getElementById', 'querySelector'],
+	['getElementsByClassName', 'querySelectorAll'],
+	['getElementsByTagName', 'querySelectorAll'],
+	['getElementsByName', 'querySelectorAll'],
+]);
+
+const getReplacementForId = value => `#${value}`;
+const getReplacementForClass = value => value.match(/\S+/g).map(className => `.${className}`).join('');
+const getReplacementForName = (value, originQuote) => `[name=${wrapQuoted(value, originQuote)}]`;
+
+const getQuotedReplacement = (node, value) => {
+	const leftQuote = node.raw.charAt(0);
+	const rightQuote = node.raw.at(-1);
+	return `${leftQuote}${value}${rightQuote}`;
+};
+
+const wrapQuoted = (value, originalQuote) => {
+	switch (originalQuote) {
+		case '\'': {
+			return `"${value}"`;
+		}
+
+		case '"': {
+			return `'${value}'`;
+		}
+
+		case '`': {
+			return `'${value}'`;
+		}
+
+		// No default
+	}
+};
+
+function * getLiteralFix(fixer, node, identifierName) {
+	let replacement = node.raw;
+	if (identifierName === 'getElementById') {
+		replacement = getQuotedReplacement(node, getReplacementForId(node.value));
+	}
+
+	if (identifierName === 'getElementsByClassName') {
+		replacement = getQuotedReplacement(node, getReplacementForClass(node.value));
+	}
+
+	if (identifierName === 'getElementsByName') {
+		const quoted = node.raw.charAt(0);
+		replacement = getQuotedReplacement(node, getReplacementForName(node.value, quoted));
+	}
+
+	yield fixer.replaceText(node, replacement);
+}
+
+function * getTemplateLiteralFix(fixer, node, identifierName) {
+	yield fixer.insertTextAfter(node, '`');
+	yield fixer.insertTextBefore(node, '`');
+
+	for (const templateElement of node.quasis) {
+		if (identifierName === 'getElementById') {
+			yield fixer.replaceText(
+				templateElement,
+				getReplacementForId(templateElement.value.cooked),
+			);
+		}
+
+		if (identifierName === 'getElementsByClassName') {
+			yield fixer.replaceText(
+				templateElement,
+				getReplacementForClass(templateElement.value.cooked),
+			);
+		}
+
+		if (identifierName === 'getElementsByName') {
+			const quoted = node.raw ? node.raw.charAt(0) : '"';
+			yield fixer.replaceText(
+				templateElement,
+				getReplacementForName(templateElement.value.cooked, quoted),
+			);
+		}
+	}
+}
+
+const canBeFixed = node =>
+	isNullLiteral(node)
+	|| (isStringLiteral(node) && Boolean(node.value.trim()))
+	|| (
+		node.type === 'TemplateLiteral'
+		&& node.expressions.length === 0
+		&& node.quasis.some(templateElement => templateElement.value.cooked.trim())
+	);
+
+const hasValue = node => {
+	if (node.type === 'Literal') {
+		return node.value;
+	}
+
+	return true;
+};
+
+const fix = (node, identifierName, preferredSelector) => {
+	const nodeToBeFixed = node.arguments[0];
+	if (identifierName === 'getElementsByTagName' || !hasValue(nodeToBeFixed)) {
+		return fixer => fixer.replaceText(node.callee.property, preferredSelector);
+	}
+
+	const getArgumentFix = nodeToBeFixed.type === 'Literal' ? getLiteralFix : getTemplateLiteralFix;
+	return function * (fixer) {
+		yield getArgumentFix(fixer, nodeToBeFixed, identifierName);
+		yield fixer.replaceText(node.callee.property, preferredSelector);
+	};
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	CallExpression(node) {
+		if (
+			!isMethodCall(node, {
+				methods: ['getElementById', 'getElementsByClassName', 'getElementsByTagName', 'getElementsByName'],
+				argumentsLength: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			|| isNodeValueNotDomNode(node.callee.object)
+		) {
+			return;
+		}
+
+		const method = node.callee.property.name;
+		const preferredSelector = disallowedIdentifierNames.get(method);
+
+		const problem = {
+			node: node.callee.property,
+			messageId: MESSAGE_ID,
+			data: {
+				replacement: preferredSelector,
+				method,
+			},
+		};
+
+		if (canBeFixed(node.arguments[0])) {
+			problem.fix = fix(node, method, preferredSelector);
+		}
+
+		return problem;
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()` and `.getElementsByName()`.',
+			recommended: true,
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-reflect-apply.js

@@ -0,0 +1,99 @@
+import {getPropertyName} from '@eslint-community/eslint-utils';
+import {isNullLiteral, isMethodCall} from './ast/index.js';
+
+const MESSAGE_ID = 'prefer-reflect-apply';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `Reflect.apply()` over `Function#apply()`.',
+};
+
+const isApplySignature = (argument1, argument2) => (
+	(
+		isNullLiteral(argument1)
+		|| argument1.type === 'ThisExpression'
+	)
+	&& (
+		argument2.type === 'ArrayExpression'
+		|| (argument2.type === 'Identifier' && argument2.name === 'arguments')
+	)
+);
+
+const getReflectApplyCall = (sourceCode, target, receiver, argumentsList) => (
+	`Reflect.apply(${sourceCode.getText(target)}, ${sourceCode.getText(receiver)}, ${sourceCode.getText(argumentsList)})`
+);
+
+const fixDirectApplyCall = (node, sourceCode) => {
+	if (
+		getPropertyName(node.callee) === 'apply'
+		&& node.arguments.length === 2
+		&& isApplySignature(node.arguments[0], node.arguments[1])
+	) {
+		return fixer => (
+			fixer.replaceText(
+				node,
+				getReflectApplyCall(sourceCode, node.callee.object, node.arguments[0], node.arguments[1]),
+			)
+		);
+	}
+};
+
+const fixFunctionPrototypeCall = (node, sourceCode) => {
+	if (
+		getPropertyName(node.callee) === 'call'
+		&& getPropertyName(node.callee.object) === 'apply'
+		&& getPropertyName(node.callee.object.object) === 'prototype'
+		&& node.callee.object.object.object?.type === 'Identifier'
+		&& node.callee.object.object.object.name === 'Function'
+		&& node.arguments.length === 3
+		&& isApplySignature(node.arguments[1], node.arguments[2])
+	) {
+		return fixer => (
+			fixer.replaceText(
+				node,
+				getReflectApplyCall(sourceCode, node.arguments[0], node.arguments[1], node.arguments[2]),
+			)
+		);
+	}
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(node) {
+		if (
+			!isMethodCall(node, {
+				optionalCall: false,
+				optionalMember: false,
+			})
+			|| node.callee.object.type === 'Literal'
+			|| node.callee.object.type === 'ArrayExpression'
+			|| node.callee.object.type === 'ObjectExpression'
+		) {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const fix = fixDirectApplyCall(node, sourceCode) || fixFunctionPrototypeCall(node, sourceCode);
+		if (fix) {
+			return {
+				node,
+				messageId: MESSAGE_ID,
+				fix,
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `Reflect.apply()` over `Function#apply()`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-regexp-test.js

@@ -0,0 +1,155 @@
+import {isParenthesized, getStaticValue} from '@eslint-community/eslint-utils';
+import {checkVueTemplate} from './utils/rule.js';
+import {isRegexLiteral, isNewExpression, isMethodCall} from './ast/index.js';
+import {isBooleanNode, shouldAddParenthesesToMemberExpressionObject} from './utils/index.js';
+
+const REGEXP_EXEC = 'regexp-exec';
+const STRING_MATCH = 'string-match';
+const SUGGESTION = 'suggestion';
+const messages = {
+	[REGEXP_EXEC]: 'Prefer `.test(…)` over `.exec(…)`.',
+	[STRING_MATCH]: 'Prefer `RegExp#test(…)` over `String#match(…)`.',
+	[SUGGESTION]: 'Switch to `RegExp#test(…)`.',
+};
+
+const cases = [
+	{
+		type: REGEXP_EXEC,
+		test: node => isMethodCall(node, {
+			method: 'exec',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		}),
+		getNodes: node => ({
+			stringNode: node.arguments[0],
+			methodNode: node.callee.property,
+			regexpNode: node.callee.object,
+		}),
+		fix: (fixer, {methodNode}) => fixer.replaceText(methodNode, 'test'),
+	},
+	{
+		type: STRING_MATCH,
+		test: node => isMethodCall(node, {
+			method: 'match',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		}),
+		getNodes: node => ({
+			stringNode: node.callee.object,
+			methodNode: node.callee.property,
+			regexpNode: node.arguments[0],
+		}),
+		* fix(fixer, {stringNode, methodNode, regexpNode}, context) {
+			const {sourceCode} = context;
+			yield fixer.replaceText(methodNode, 'test');
+
+			let stringText = sourceCode.getText(stringNode);
+			if (
+				!isParenthesized(regexpNode, sourceCode)
+				// Only `SequenceExpression` need add parentheses
+				&& stringNode.type === 'SequenceExpression'
+			) {
+				stringText = `(${stringText})`;
+			}
+
+			yield fixer.replaceText(regexpNode, stringText);
+
+			let regexpText = sourceCode.getText(regexpNode);
+			if (
+				!isParenthesized(stringNode, sourceCode)
+				&& shouldAddParenthesesToMemberExpressionObject(regexpNode, context)
+			) {
+				regexpText = `(${regexpText})`;
+			}
+
+			// The nodes that pass `isBooleanNode` cannot have an ASI problem.
+
+			yield fixer.replaceText(stringNode, regexpText);
+		},
+	},
+];
+
+const isRegExpNode = node => isRegexLiteral(node) || isNewExpression(node, {name: 'RegExp'});
+
+const isRegExpWithoutGlobalFlag = (node, scope) => {
+	if (isRegexLiteral(node)) {
+		return !node.regex.flags.includes('g');
+	}
+
+	const staticResult = getStaticValue(node, scope);
+
+	// Don't know if there is `g` flag
+	if (!staticResult) {
+		return false;
+	}
+
+	const {value} = staticResult;
+	return (
+		Object.prototype.toString.call(value) === '[object RegExp]'
+		&& !value.global
+	);
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	* CallExpression(node) {
+		if (!isBooleanNode(node)) {
+			return;
+		}
+
+		for (const {type, test, getNodes, fix} of cases) {
+			if (!test(node)) {
+				continue;
+			}
+
+			const nodes = getNodes(node);
+			const {methodNode, regexpNode} = nodes;
+
+			if (regexpNode.type === 'Literal' && !regexpNode.regex) {
+				continue;
+			}
+
+			const problem = {
+				node: type === REGEXP_EXEC ? methodNode : node,
+				messageId: type,
+			};
+
+			const fixFunction = fixer => fix(fixer, nodes, context);
+
+			if (
+				isRegExpNode(regexpNode)
+				|| isRegExpWithoutGlobalFlag(regexpNode, context.sourceCode.getScope(regexpNode))
+			) {
+				problem.fix = fixFunction;
+			} else {
+				problem.suggest = [
+					{
+						messageId: SUGGESTION,
+						fix: fixFunction,
+					},
+				];
+			}
+
+			yield problem;
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create: checkVueTemplate(create),
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `RegExp#test()` over `String#match()` and `RegExp#exec()`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;