@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-response-static-json.js

@@ -1,85 +0,0 @@
-import {
-	isNewExpression,
-	isMethodCall,
-} from './ast/index.js';
-import {
-	switchNewExpressionToCallExpression,
-} from './fix/index.js';
-import {
-	getParenthesizedRange,
-	isParenthesized,
-	needsSemicolon,
-} from './utils/index.js';
-
-const MESSAGE_ID = 'prefer-response-static-json';
-const messages = {
-	[MESSAGE_ID]: 'Prefer using `Response.json(…)` over `JSON.stringify()`.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	NewExpression(newExpression) {
-		if (!isNewExpression(newExpression, {name: 'Response', minimumArguments: 1})) {
-			return;
-		}
-
-		const [jsonStringifyNode] = newExpression.arguments;
-		if (!isMethodCall(jsonStringifyNode, {
-			object: 'JSON',
-			method: 'stringify',
-			argumentsLength: 1,
-			optionalCall: false,
-			optionalMember: false,
-		})) {
-			return;
-		}
-
-		return {
-			node: jsonStringifyNode.callee,
-			messageId: MESSAGE_ID,
-			/** @param {import('eslint').Rule.RuleFixer} fixer */
-			* fix(fixer) {
-				yield fixer.insertTextAfter(newExpression.callee, '.json');
-				yield switchNewExpressionToCallExpression(newExpression, context, fixer);
-
-				const [dataNode] = jsonStringifyNode.arguments;
-				const callExpressionRange = getParenthesizedRange(jsonStringifyNode, context);
-				const dataNodeRange = getParenthesizedRange(dataNode, context);
-				// `(( JSON.stringify( (( data )), ) ))`
-				//  ^^^^^^^^^^^^^^^^^^^
-				yield fixer.removeRange([callExpressionRange[0], dataNodeRange[0]]);
-				// `(( JSON.stringify( (( data )), ) ))`
-				//                               ^^^^^^
-				yield fixer.removeRange([dataNodeRange[1], callExpressionRange[1]]);
-
-				const {sourceCode} = context;
-				if (
-					!isParenthesized(newExpression, sourceCode)
-					&& isParenthesized(newExpression.callee, sourceCode)
-				) {
-					const tokenBefore = sourceCode.getTokenBefore(newExpression);
-					if (needsSemicolon(tokenBefore, context, '(')) {
-						yield fixer.insertTextBefore(newExpression, ';');
-					}
-				}
-			},
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `Response.json()` over `new Response(JSON.stringify())`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-set-has.js

@@ -1,181 +0,0 @@
-import {findVariable} from '@eslint-community/eslint-utils';
-import {getVariableIdentifiers} from './utils/index.js';
-import {isCallOrNewExpression, isMethodCall} from './ast/index.js';
-
-const MESSAGE_ID_ERROR = 'error';
-const MESSAGE_ID_SUGGESTION = 'suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: '`{{name}}` should be a `Set`, and use `{{name}}.has()` to check existence or non-existence.',
-	[MESSAGE_ID_SUGGESTION]: 'Switch `{{name}}` to `Set`.',
-};
-
-const arrayMethodsReturnsArray = [
-	'concat',
-	'copyWithin',
-	'fill',
-	'filter',
-	'flat',
-	'flatMap',
-	'map',
-	'reverse',
-	'slice',
-	'sort',
-	'splice',
-	'toReversed',
-	'toSorted',
-	'toSpliced',
-	'with',
-];
-
-const isIncludesCall = node =>
-	isMethodCall(node.parent.parent, {
-		method: 'includes',
-		optionalCall: false,
-		optionalMember: false,
-		argumentsLength: 1,
-	})
-	&& node.parent.object === node;
-
-const multipleCallNodeTypes = new Set([
-	'ForOfStatement',
-	'ForStatement',
-	'ForInStatement',
-	'WhileStatement',
-	'DoWhileStatement',
-	'FunctionDeclaration',
-	'FunctionExpression',
-	'ArrowFunctionExpression',
-]);
-
-const isMultipleCall = (identifier, node) => {
-	const root = node.parent.parent.parent;
-	let {parent} = identifier.parent; // `.include()` callExpression
-	while (
-		parent
-		&& parent !== root
-	) {
-		if (multipleCallNodeTypes.has(parent.type)) {
-			return true;
-		}
-
-		parent = parent.parent;
-	}
-
-	return false;
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	Identifier(node) {
-		const {parent} = node;
-
-		if (!(
-			parent.type === 'VariableDeclarator'
-			&& parent.id === node
-			&& Boolean(parent.init)
-			&& parent.parent.type === 'VariableDeclaration'
-			&& parent.parent.declarations.includes(parent)
-			// Exclude `export const foo = [];`
-			&& !(
-				parent.parent.parent.type === 'ExportNamedDeclaration'
-				&& parent.parent.parent.declaration === parent.parent
-			)
-			&& (
-				// `[]`
-				parent.init.type === 'ArrayExpression'
-				// `Array()` and `new Array()`
-				|| isCallOrNewExpression(parent.init, {
-					name: 'Array',
-					optional: false,
-				})
-				// `Array.from()` and `Array.of()`
-				|| isMethodCall(parent.init, {
-					object: 'Array',
-					methods: ['from', 'of'],
-					optionalCall: false,
-					optionalMember: false,
-				})
-				// Array methods that return an array
-				|| isMethodCall(parent.init, {
-					methods: arrayMethodsReturnsArray,
-					optionalCall: false,
-					optionalMember: false,
-				})
-			)
-		)) {
-			return;
-		}
-
-		const variable = findVariable(context.sourceCode.getScope(node), node);
-
-		// This was reported https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1075#issuecomment-768073342
-		// But can't reproduce, just ignore this case
-		/* c8 ignore next 3 */
-		if (!variable) {
-			return;
-		}
-
-		const identifiers = getVariableIdentifiers(variable).filter(identifier => identifier !== node);
-
-		if (
-			identifiers.length === 0
-			|| identifiers.some(identifier => !isIncludesCall(identifier))
-		) {
-			return;
-		}
-
-		if (
-			identifiers.length === 1
-			&& identifiers.every(identifier => !isMultipleCall(identifier, node))
-		) {
-			return;
-		}
-
-		const problem = {
-			node,
-			messageId: MESSAGE_ID_ERROR,
-			data: {
-				name: node.name,
-			},
-		};
-
-		const fix = function * (fixer) {
-			yield fixer.insertTextBefore(node.parent.init, 'new Set(');
-			yield fixer.insertTextAfter(node.parent.init, ')');
-
-			for (const identifier of identifiers) {
-				yield fixer.replaceText(identifier.parent.property, 'has');
-			}
-		};
-
-		if (node.typeAnnotation) {
-			problem.suggest = [
-				{
-					messageId: MESSAGE_ID_SUGGESTION,
-					fix,
-				},
-			];
-		} else {
-			problem.fix = fix;
-		}
-
-		return problem;
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-set-size.js

@@ -1,106 +0,0 @@
-import {findVariable} from '@eslint-community/eslint-utils';
-import {fixSpaceAroundKeyword} from './fix/index.js';
-import {isNewExpression, isMemberExpression} from './ast/index.js';
-
-const MESSAGE_ID = 'prefer-set-size';
-const messages = {
-	[MESSAGE_ID]: 'Prefer using `Set#size` instead of `Array#length`.',
-};
-
-const isNewSet = node => isNewExpression(node, {name: 'Set'});
-
-function isSet(node, scope) {
-	if (isNewSet(node)) {
-		return true;
-	}
-
-	if (node.type !== 'Identifier') {
-		return false;
-	}
-
-	const variable = findVariable(scope, node);
-
-	if (!variable || variable.defs.length !== 1) {
-		return false;
-	}
-
-	const [definition] = variable.defs;
-
-	if (definition.type !== 'Variable' || definition.kind !== 'const') {
-		return false;
-	}
-
-	const declarator = definition.node;
-	return declarator.type === 'VariableDeclarator'
-		&& declarator.id.type === 'Identifier'
-		&& isNewSet(definition.node.init);
-}
-
-// `[...set].length` -> `set.size`
-function fix(context, lengthAccessNodes) {
-	const {sourceCode} = context;
-	const {
-		object: arrayExpression,
-		property,
-	} = lengthAccessNodes;
-	const set = arrayExpression.elements[0].argument;
-
-	if (sourceCode.getCommentsInside(arrayExpression).length > sourceCode.getCommentsInside(set).length) {
-		return;
-	}
-
-	/** @param {import('eslint').Rule.RuleFixer} fixer */
-	return function * (fixer) {
-		yield fixer.replaceText(property, 'size');
-		yield fixer.replaceText(arrayExpression, sourceCode.getText(set));
-		yield fixSpaceAroundKeyword(fixer, lengthAccessNodes, context);
-	};
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-
-	return {
-		MemberExpression(node) {
-			if (
-				!isMemberExpression(node, {
-					property: 'length',
-					optional: false,
-				})
-				|| node.object.type !== 'ArrayExpression'
-				|| node.object.elements.length !== 1
-				|| node.object.elements[0]?.type !== 'SpreadElement'
-			) {
-				return;
-			}
-
-			const maybeSet = node.object.elements[0].argument;
-			if (!isSet(maybeSet, sourceCode.getScope(maybeSet))) {
-				return;
-			}
-
-			return {
-				node: node.property,
-				messageId: MESSAGE_ID,
-				fix: fix(context, node),
-			};
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer using `Set#size` instead of `Array#length`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-single-call.js

@@ -1,188 +0,0 @@
-import {hasSideEffect, isSemicolonToken} from '@eslint-community/eslint-utils';
-import {
-	getCallExpressionTokens,
-	getCallExpressionArgumentsText,
-	isSameReference,
-	isNodeMatches,
-	getPreviousNode,
-} from './utils/index.js';
-import {isMethodCall, isMemberExpression, isCallExpression} from './ast/index.js';
-
-const ERROR = 'error/array-push';
-const SUGGESTION = 'suggestion';
-const messages = {
-	[ERROR]: 'Do not call `{{description}}` multiple times.',
-	[SUGGESTION]: 'Merge with previous one.',
-};
-
-const isClassList = node => isMemberExpression(node, {
-	property: 'classList',
-	computed: false,
-});
-
-const cases = [
-	{
-		description: 'Array#push()',
-		test: callExpression => isMethodCall(callExpression, {
-			method: 'push',
-			optionalCall: false,
-		}),
-		ignore: [
-			'stream.push',
-			'this.push',
-			'this.stream.push',
-			'process.stdin.push',
-			'process.stdout.push',
-			'process.stderr.push',
-		],
-	},
-	{
-		description: 'Element#classList.add()',
-		test: callExpression =>
-			isMethodCall(callExpression, {
-				method: 'add',
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& isClassList(callExpression.callee.object),
-	},
-	{
-		description: 'Element#classList.remove()',
-		test: callExpression =>
-			isMethodCall(callExpression, {
-				method: 'remove',
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& isClassList(callExpression.callee.object),
-	},
-	{
-		description: 'importScripts()',
-		test: callExpression => isCallExpression(callExpression, {name: 'importScripts'}),
-	},
-];
-
-function create(context) {
-	const {
-		ignore: ignoredCalleeInOptions,
-	} = {
-		ignore: [],
-		...context.options[0],
-	};
-	const {sourceCode} = context;
-
-	return {
-		* CallExpression(secondCall) {
-			for (const {description, test, ignore = []} of cases) {
-				if (!test(secondCall)) {
-					continue;
-				}
-
-				const ignoredCallee = [...ignore, ...ignoredCalleeInOptions];
-				if (isNodeMatches(secondCall.callee, ignoredCallee)) {
-					continue;
-				}
-
-				let secondExpressionStatement = secondCall.parent;
-				if (secondExpressionStatement.type === 'ChainExpression' && secondCall === secondExpressionStatement.expression) {
-					secondExpressionStatement = secondExpressionStatement.parent;
-				}
-
-				if (secondExpressionStatement.type !== 'ExpressionStatement') {
-					continue;
-				}
-
-				const firstExpressionStatement = getPreviousNode(secondExpressionStatement, context);
-				if (firstExpressionStatement?.type !== 'ExpressionStatement') {
-					continue;
-				}
-
-				let firstCall = firstExpressionStatement.expression;
-
-				if (firstCall.type === 'ChainExpression') {
-					firstCall = firstCall.expression;
-				}
-
-				if (!test(firstCall) || !isSameReference(firstCall.callee, secondCall.callee)) {
-					continue;
-				}
-
-				const secondCallArguments = secondCall.arguments;
-				const problem = {
-					node: secondCall.callee.type === 'Identifier' ? secondCall.callee : secondCall.callee.property,
-					messageId: ERROR,
-					data: {description},
-				};
-
-				const fix = function * (fixer) {
-					if (secondCallArguments.length > 0) {
-						const text = getCallExpressionArgumentsText(context, secondCall);
-
-						const {
-							trailingCommaToken,
-							closingParenthesisToken,
-						} = getCallExpressionTokens(firstCall, context);
-
-						yield (
-							trailingCommaToken
-								? fixer.insertTextAfter(trailingCommaToken, ` ${text}`)
-								: fixer.insertTextBefore(closingParenthesisToken, firstCall.arguments.length > 0 ? `, ${text}` : text)
-						);
-					}
-
-					const shouldKeepSemicolon = !isSemicolonToken(sourceCode.getLastToken(firstExpressionStatement))
-						&& isSemicolonToken(sourceCode.getLastToken(secondExpressionStatement));
-					const [, start] = sourceCode.getRange(firstExpressionStatement);
-					const [, end] = sourceCode.getRange(secondExpressionStatement);
-
-					yield fixer.replaceTextRange([start, end], shouldKeepSemicolon ? ';' : '');
-				};
-
-				if (secondCallArguments.some(element => hasSideEffect(element, sourceCode))) {
-					problem.suggest = [
-						{
-							messageId: SUGGESTION,
-							fix,
-						},
-					];
-				} else {
-					problem.fix = fix;
-				}
-
-				yield problem;
-			}
-		},
-	};
-}
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			ignore: {
-				type: 'array',
-				uniqueItems: true,
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Enforce combining multiple `Array#push()`, `Element#classList.{add,remove}()`, and `importScripts()` into one call.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		schema,
-		defaultOptions: [{}],
-		messages,
-	},
-};
-
-export default config;