@alexlit/lint-kit 176.0.1 → 177.0.0

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

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

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

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

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

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