@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-array-flat.js

@@ -1,279 +0,0 @@
-import {
-	getParenthesizedText,
-	isArrayPrototypeProperty,
-	isNodeMatches,
-	isNodeMatchesNameOrPath,
-	isParenthesized,
-	isSameIdentifier,
-	needsSemicolon,
-	shouldAddParenthesesToMemberExpressionObject,
-} from './utils/index.js';
-import {fixSpaceAroundKeyword} from './fix/index.js';
-import {isMethodCall, isCallExpression, isEmptyArrayExpression} from './ast/index.js';
-
-const MESSAGE_ID = 'prefer-array-flat';
-const messages = {
-	[MESSAGE_ID]: 'Prefer `Array#flat()` over `{{description}}` to flatten an array.',
-};
-
-// `array.flatMap(x => x)`
-const arrayFlatMap = {
-	testFunction(node) {
-		if (!isMethodCall(node, {
-			method: 'flatMap',
-			argumentsLength: 1,
-			optionalCall: false,
-		})) {
-			return false;
-		}
-
-		const [firstArgument] = node.arguments;
-		return (
-			firstArgument.type === 'ArrowFunctionExpression'
-			&& !firstArgument.async
-			&& firstArgument.params.length === 1
-			&& isSameIdentifier(firstArgument.params[0], firstArgument.body)
-		);
-	},
-	getArrayNode: node => node.callee.object,
-	isOptionalArray: node => node.callee.optional,
-	description: 'Array#flatMap()',
-};
-
-// `array.reduce((a, b) => a.concat(b), [])`
-// `array?.reduce((a, b) => a.concat(b), [])`
-// `array.reduce((a, b) => [...a, ...b], [])`
-// `array?.reduce((a, b) => [...a, ...b], [])`
-const arrayReduce = {
-	testFunction(node) {
-		if (!isMethodCall(node, {
-			method: 'reduce',
-			argumentsLength: 2,
-			optionalCall: false,
-		})) {
-			return false;
-		}
-
-		const [firstArgument, secondArgument] = node.arguments;
-		if (!(
-			firstArgument.type === 'ArrowFunctionExpression'
-			&& !firstArgument.async
-			&& firstArgument.params.length === 2
-			&& isEmptyArrayExpression(secondArgument)
-		)) {
-			return false;
-		}
-
-		const firstArgumentBody = firstArgument.body;
-		const [firstParameter, secondParameter] = firstArgument.params;
-		return (
-			// `(a, b) => a.concat(b)`
-			(
-				isMethodCall(firstArgumentBody, {
-					method: 'concat',
-					argumentsLength: 1,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				&& isSameIdentifier(firstParameter, firstArgumentBody.callee.object)
-				&& isSameIdentifier(secondParameter, firstArgumentBody.arguments[0])
-			)
-			// `(a, b) => [...a, ...b]`
-			|| (
-				firstArgumentBody.type === 'ArrayExpression'
-				&& firstArgumentBody.elements.length === 2
-				&& firstArgumentBody.elements.every((node, index) =>
-					node?.type === 'SpreadElement'
-					&& node.argument.type === 'Identifier'
-					&& isSameIdentifier(firstArgument.params[index], node.argument),
-				)
-			)
-		);
-	},
-	getArrayNode: node => node.callee.object,
-	isOptionalArray: node => node.callee.optional,
-	description: 'Array#reduce()',
-};
-
-// `[].concat(maybeArray)`
-// `[].concat(...array)`
-const emptyArrayConcat = {
-	testFunction(node) {
-		return isMethodCall(node, {
-			method: 'concat',
-			argumentsLength: 1,
-			allowSpreadElement: true,
-			optionalCall: false,
-			optionalMember: false,
-		})
-		&& isEmptyArrayExpression(node.callee.object);
-	},
-	getArrayNode(node) {
-		const argumentNode = node.arguments[0];
-		return argumentNode.type === 'SpreadElement' ? argumentNode.argument : argumentNode;
-	},
-	description: '[].concat()',
-	shouldSwitchToArray: node => node.arguments[0].type !== 'SpreadElement',
-};
-
-// - `[].concat.apply([], array)` and `Array.prototype.concat.apply([], array)`
-// - `[].concat.call([], maybeArray)` and `Array.prototype.concat.call([], maybeArray)`
-// - `[].concat.call([], ...array)` and `Array.prototype.concat.call([], ...array)`
-const arrayPrototypeConcat = {
-	testFunction(node) {
-		if (!(
-			isMethodCall(node, {
-				methods: ['apply', 'call'],
-				argumentsLength: 2,
-				allowSpreadElement: true,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& isArrayPrototypeProperty(node.callee.object, {
-				property: 'concat',
-			})
-		)) {
-			return false;
-		}
-
-		const [firstArgument, secondArgument] = node.arguments;
-		return isEmptyArrayExpression(firstArgument)
-			&& (
-				node.callee.property.name === 'call'
-				|| secondArgument.type !== 'SpreadElement'
-			);
-	},
-	getArrayNode(node) {
-		const argumentNode = node.arguments[1];
-		return argumentNode.type === 'SpreadElement' ? argumentNode.argument : argumentNode;
-	},
-	description: 'Array.prototype.concat()',
-	shouldSwitchToArray: node => node.arguments[1].type !== 'SpreadElement' && node.callee.property.name === 'call',
-};
-
-const lodashFlattenFunctions = [
-	'_.flatten',
-	'lodash.flatten',
-	'underscore.flatten',
-];
-
-function fix(node, array, context, shouldSwitchToArray, optional) {
-	if (typeof shouldSwitchToArray === 'function') {
-		shouldSwitchToArray = shouldSwitchToArray(node);
-	}
-
-	return function * (fixer) {
-		const {sourceCode} = context;
-		let fixed = getParenthesizedText(array, context);
-		if (shouldSwitchToArray) {
-			// `array` is an argument, when it changes to `array[]`, we don't need add extra parentheses
-			fixed = `[${fixed}]`;
-			// And we don't need to add parentheses to the new array to call `.flat()`
-		} else if (
-			!isParenthesized(array, sourceCode)
-			&& shouldAddParenthesesToMemberExpressionObject(array, context)
-		) {
-			fixed = `(${fixed})`;
-		}
-
-		fixed = `${fixed}${optional ? '?' : ''}.flat()`;
-
-		const tokenBefore = sourceCode.getTokenBefore(node);
-		if (needsSemicolon(tokenBefore, context, fixed)) {
-			fixed = `;${fixed}`;
-		}
-
-		yield fixer.replaceText(node, fixed);
-
-		yield fixSpaceAroundKeyword(fixer, node, context);
-	};
-}
-
-function create(context) {
-	const {functions: configFunctions} = {
-		functions: [],
-		...context.options[0],
-	};
-	const functions = [...configFunctions, ...lodashFlattenFunctions];
-
-	const cases = [
-		arrayFlatMap,
-		arrayReduce,
-		emptyArrayConcat,
-		arrayPrototypeConcat,
-		{
-			testFunction: node => isCallExpression(node, {
-				argumentsLength: 1,
-				optional: false,
-			}) && isNodeMatches(node.callee, functions),
-			getArrayNode: node => node.arguments[0],
-			description: node => `${functions.find(nameOrPath => isNodeMatchesNameOrPath(node.callee, nameOrPath)).trim()}()`,
-		},
-	];
-
-	return {
-		* CallExpression(node) {
-			for (const {testFunction, description, getArrayNode, shouldSwitchToArray, isOptionalArray} of cases) {
-				if (!testFunction(node)) {
-					continue;
-				}
-
-				const array = getArrayNode(node);
-				const optional = isOptionalArray?.(node);
-
-				const data = {
-					description: typeof description === 'string' ? description : description(node),
-				};
-
-				const problem = {
-					node,
-					messageId: MESSAGE_ID,
-					data,
-				};
-
-				const {sourceCode} = context;
-
-				// Don't fix if it has comments.
-				if (
-					sourceCode.getCommentsInside(node).length
-					=== sourceCode.getCommentsInside(array).length
-				) {
-					problem.fix = fix(node, array, context, shouldSwitchToArray, optional);
-				}
-
-				yield problem;
-			}
-		},
-	};
-}
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			functions: {
-				type: 'array',
-				uniqueItems: true,
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `Array#flat()` over legacy techniques to flatten arrays.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: [{}],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-array-index-of.js

@@ -1,34 +0,0 @@
-import simpleArraySearchRule from './shared/simple-array-search-rule.js';
-
-const indexOfOverFindIndexRule = simpleArraySearchRule({
-	method: 'findIndex',
-	replacement: 'indexOf',
-});
-
-const lastIndexOfOverFindLastIndexRule = simpleArraySearchRule({
-	method: 'findLastIndex',
-	replacement: 'lastIndexOf',
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create(context) {
-		indexOfOverFindIndexRule.listen(context);
-		lastIndexOfOverFindLastIndexRule.listen(context);
-	},
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `Array#{indexOf,lastIndexOf}()` over `Array#{findIndex,findLastIndex}()` when looking for the index of an item.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages: {
-			...indexOfOverFindIndexRule.messages,
-			...lastIndexOfOverFindLastIndexRule.messages,
-		},
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-array-some.js

@@ -1,219 +0,0 @@
-import {checkVueTemplate} from './utils/rule.js';
-import {isBooleanNode, getParenthesizedRange, isNodeValueNotFunction} from './utils/index.js';
-import {removeMemberExpressionProperty} from './fix/index.js';
-import {
-	isLiteral,
-	isUndefined,
-	isMethodCall,
-	isMemberExpression,
-} from './ast/index.js';
-
-const ERROR_ID_ARRAY_SOME = 'some';
-const SUGGESTION_ID_ARRAY_SOME = 'some-suggestion';
-const ERROR_ID_ARRAY_FILTER = 'filter';
-const messages = {
-	[ERROR_ID_ARRAY_SOME]: 'Prefer `.some(…)` over `.{{method}}(…)`.',
-	[SUGGESTION_ID_ARRAY_SOME]: 'Replace `.{{method}}(…)` with `.some(…)`.',
-	[ERROR_ID_ARRAY_FILTER]: 'Prefer `.some(…)` over non-zero length check from `.filter(…)`.',
-};
-
-const isCheckingUndefined = node =>
-	node.parent.type === 'BinaryExpression'
-	// Not checking yoda expression `null != foo.find()` and `undefined !== foo.find()
-	&& node.parent.left === node
-	&& (
-		(
-			(
-				node.parent.operator === '!='
-				|| node.parent.operator === '=='
-				|| node.parent.operator === '==='
-				|| node.parent.operator === '!=='
-			)
-			&& isUndefined(node.parent.right)
-		)
-		|| (
-			(
-				node.parent.operator === '!='
-				|| node.parent.operator === '=='
-			)
-			// eslint-disable-next-line unicorn/no-null
-			&& isLiteral(node.parent.right, null)
-		)
-	);
-const isNegativeOne = node => node.type === 'UnaryExpression' && node.operator === '-' && node.argument && node.argument.type === 'Literal' && node.argument.value === 1;
-const isLiteralZero = node => isLiteral(node, 0);
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	// `.find(…)`
-	// `.findLast(…)`
-	context.on('CallExpression', callExpression => {
-		if (!isMethodCall(callExpression, {
-			methods: ['find', 'findLast'],
-			minimumArguments: 1,
-			maximumArguments: 2,
-			optionalCall: false,
-			optionalMember: false,
-		})) {
-			return;
-		}
-
-		const isCompare = isCheckingUndefined(callExpression);
-		if (!isCompare && !isBooleanNode(callExpression)) {
-			return;
-		}
-
-		const methodNode = callExpression.callee.property;
-		return {
-			node: methodNode,
-			messageId: ERROR_ID_ARRAY_SOME,
-			data: {method: methodNode.name},
-			suggest: [
-				{
-					messageId: SUGGESTION_ID_ARRAY_SOME,
-					* fix(fixer) {
-						yield fixer.replaceText(methodNode, 'some');
-
-						if (!isCompare) {
-							return;
-						}
-
-						const {sourceCode} = context;
-						const parenthesizedRange = getParenthesizedRange(callExpression, context);
-						yield fixer.removeRange([parenthesizedRange[1], sourceCode.getRange(callExpression.parent)[1]]);
-
-						if (callExpression.parent.operator === '!=' || callExpression.parent.operator === '!==') {
-							return;
-						}
-
-						yield fixer.insertTextBeforeRange(parenthesizedRange, '!');
-					},
-				},
-			],
-		};
-	});
-
-	// These operators also used in `prefer-includes`, try to reuse the code in future
-	// `.{findIndex,findLastIndex}(…) !== -1`
-	// `.{findIndex,findLastIndex}(…) != -1`
-	// `.{findIndex,findLastIndex}(…) > -1`
-	// `.{findIndex,findLastIndex}(…) === -1`
-	// `.{findIndex,findLastIndex}(…) == -1`
-	// `.{findIndex,findLastIndex}(…) >= 0`
-	// `.{findIndex,findLastIndex}(…) < 0`
-	context.on('BinaryExpression', binaryExpression => {
-		const {left, right, operator} = binaryExpression;
-
-		if (!(
-			isMethodCall(left, {
-				methods: ['findIndex', 'findLastIndex'],
-				argumentsLength: 1,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& (
-				(['!==', '!=', '>', '===', '=='].includes(operator) && isNegativeOne(right))
-				|| (['>=', '<'].includes(operator) && isLiteralZero(right))
-			)
-		)) {
-			return;
-		}
-
-		const methodNode = left.callee.property;
-		return {
-			node: methodNode,
-			messageId: ERROR_ID_ARRAY_SOME,
-			data: {method: methodNode.name},
-			* fix(fixer) {
-				if (['===', '==', '<'].includes(operator)) {
-					yield fixer.insertTextBefore(binaryExpression, '!');
-				}
-
-				yield fixer.replaceText(methodNode, 'some');
-
-				const {sourceCode} = context;
-				const operatorToken = sourceCode.getTokenAfter(
-					left,
-					token => token.type === 'Punctuator' && token.value === operator,
-				);
-				const [start] = sourceCode.getRange(operatorToken);
-				const [, end] = sourceCode.getRange(binaryExpression);
-
-				yield fixer.removeRange([start, end]);
-			},
-		};
-	});
-
-	// `.filter(…).length > 0`
-	// `.filter(…).length !== 0`
-	context.on('BinaryExpression', binaryExpression => {
-		if (!(
-			// We assume the user already follows `unicorn/explicit-length-check`. These are allowed in that rule.
-			(binaryExpression.operator === '>' || binaryExpression.operator === '!==')
-			&& binaryExpression.right.type === 'Literal'
-			&& binaryExpression.right.raw === '0'
-			&& isMemberExpression(binaryExpression.left, {property: 'length', optional: false})
-			&& isMethodCall(binaryExpression.left.object, {
-				method: 'filter',
-				optionalCall: false,
-				optionalMember: false,
-			})
-		)) {
-			return;
-		}
-
-		const filterCall = binaryExpression.left.object;
-		const [firstArgument] = filterCall.arguments;
-		if (!firstArgument || isNodeValueNotFunction(firstArgument)) {
-			return;
-		}
-
-		const filterProperty = filterCall.callee.property;
-		return {
-			node: filterProperty,
-			messageId: ERROR_ID_ARRAY_FILTER,
-			* fix(fixer) {
-				// `.filter` to `.some`
-				yield fixer.replaceText(filterProperty, 'some');
-
-				const {sourceCode} = context;
-				const lengthNode = binaryExpression.left;
-				/*
-					Remove `.length`
-					`(( (( array.filter() )).length )) > (( 0 ))`
-					------------------------^^^^^^^
-				*/
-				yield removeMemberExpressionProperty(fixer, lengthNode, context);
-
-				/*
-					Remove `> 0`
-					`(( (( array.filter() )).length )) > (( 0 ))`
-					----------------------------------^^^^^^^^^^
-				*/
-				yield fixer.removeRange([
-					getParenthesizedRange(lengthNode, context)[1],
-					sourceCode.getRange(binaryExpression)[1],
-				]);
-
-				// The `BinaryExpression` always ends with a number or `)`, no need check for ASI
-			},
-		};
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create: checkVueTemplate(create),
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast,findIndex,findLastIndex}(…)`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-		hasSuggestions: true,
-	},
-};
-
-export default config;