@alexlit/lint-kit 175.0.0 → 176.0.1

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-array-for-each.js

@@ -0,0 +1,496 @@
+import {
+	isParenthesized,
+	isCommaToken,
+	isSemicolonToken,
+	isClosingParenToken,
+	findVariable,
+	hasSideEffect,
+} from '@eslint-community/eslint-utils';
+import {
+	extendFixRange,
+	fixSpaceAroundKeyword,
+	removeParentheses,
+} from './fix/index.js';
+import needsSemicolon from './utils/needs-semicolon.js';
+import shouldAddParenthesesToExpressionStatementExpression from './utils/should-add-parentheses-to-expression-statement-expression.js';
+import shouldAddParenthesesToMemberExpressionObject from './utils/should-add-parentheses-to-member-expression-object.js';
+import {getParentheses, getParenthesizedRange} from './utils/parentheses.js';
+import isFunctionSelfUsedInside from './utils/is-function-self-used-inside.js';
+import {isNodeMatches} from './utils/is-node-matches.js';
+import assertToken from './utils/assert-token.js';
+import {
+	isArrowFunctionBody,
+	isMethodCall,
+	isReferenceIdentifier,
+	functionTypes,
+} from './ast/index.js';
+
+const MESSAGE_ID_ERROR = 'no-array-for-each/error';
+const MESSAGE_ID_SUGGESTION = 'no-array-for-each/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Use `for…of` instead of `.forEach(…)`.',
+	[MESSAGE_ID_SUGGESTION]: 'Switch to `for…of`.',
+};
+
+const continueAbleNodeTypes = new Set([
+	'WhileStatement',
+	'DoWhileStatement',
+	'ForStatement',
+	'ForOfStatement',
+	'ForInStatement',
+]);
+
+const stripChainExpression = node =>
+	(node.parent.type === 'ChainExpression' && node.parent.expression === node)
+		? node.parent
+		: node;
+
+function isReturnStatementInContinueAbleNodes(returnStatement, callbackFunction) {
+	for (let node = returnStatement; node && node !== callbackFunction; node = node.parent) {
+		if (continueAbleNodeTypes.has(node.type)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function shouldSwitchReturnStatementToBlockStatement(returnStatement) {
+	const {parent} = returnStatement;
+
+	switch (parent.type) {
+		case 'IfStatement': {
+			return parent.consequent === returnStatement || parent.alternate === returnStatement;
+		}
+
+		// These parent's body need switch to `BlockStatement` too, but since they are "continueAble", won't fix
+		// case 'ForStatement':
+		// case 'ForInStatement':
+		// case 'ForOfStatement':
+		// case 'WhileStatement':
+		// case 'DoWhileStatement':
+		case 'WithStatement': {
+			return parent.body === returnStatement;
+		}
+
+		default: {
+			return false;
+		}
+	}
+}
+
+function getFixFunction(callExpression, functionInfo, context) {
+	const {sourceCode} = context;
+	const [callback] = callExpression.arguments;
+	const parameters = callback.params;
+	const iterableObject = callExpression.callee.object;
+	const {returnStatements} = functionInfo.get(callback);
+	const isOptionalObject = callExpression.callee.optional;
+	const ancestor = stripChainExpression(callExpression).parent;
+	const objectText = sourceCode.getText(iterableObject);
+
+	const getForOfLoopHeadText = () => {
+		const [elementText, indexText] = parameters.map(parameter => sourceCode.getText(parameter));
+		const shouldUseEntries = parameters.length === 2;
+
+		let text = 'for (';
+		text += isFunctionParameterVariableReassigned(callback, sourceCode) ? 'let' : 'const';
+		text += ' ';
+		text += shouldUseEntries ? `[${indexText}, ${elementText}]` : elementText;
+		text += ' of ';
+
+		const shouldAddParenthesesToObject
+			= isParenthesized(iterableObject, sourceCode)
+				|| (
+				// `1?.forEach()` -> `(1).entries()`
+					isOptionalObject
+					&& shouldUseEntries
+					&& shouldAddParenthesesToMemberExpressionObject(iterableObject, context)
+				);
+
+		text += shouldAddParenthesesToObject ? `(${objectText})` : objectText;
+
+		if (shouldUseEntries) {
+			text += '.entries()';
+		}
+
+		text += ') ';
+
+		return text;
+	};
+
+	const getForOfLoopHeadRange = () => {
+		const [start] = sourceCode.getRange(callExpression);
+		const [end] = getParenthesizedRange(callback.body, context);
+		return [start, end];
+	};
+
+	function * replaceReturnStatement(returnStatement, fixer) {
+		const returnToken = sourceCode.getFirstToken(returnStatement);
+		assertToken(returnToken, {
+			expected: 'return',
+			ruleId: 'no-array-for-each',
+		});
+
+		if (!returnStatement.argument) {
+			yield fixer.replaceText(returnToken, 'continue');
+			return;
+		}
+
+		// Remove `return`
+		yield fixer.remove(returnToken);
+
+		const previousToken = sourceCode.getTokenBefore(returnToken);
+		const nextToken = sourceCode.getTokenAfter(returnToken);
+		let textBefore = '';
+		let textAfter = '';
+		const shouldAddParentheses
+			= !isParenthesized(returnStatement.argument, sourceCode)
+				&& shouldAddParenthesesToExpressionStatementExpression(returnStatement.argument);
+		if (shouldAddParentheses) {
+			textBefore = `(${textBefore}`;
+			textAfter = `${textAfter})`;
+		}
+
+		const insertBraces = shouldSwitchReturnStatementToBlockStatement(returnStatement);
+		if (insertBraces) {
+			textBefore = `{ ${textBefore}`;
+		} else if (needsSemicolon(previousToken, context, shouldAddParentheses ? '(' : nextToken.value)) {
+			textBefore = `;${textBefore}`;
+		}
+
+		if (textBefore) {
+			yield fixer.insertTextBefore(nextToken, textBefore);
+		}
+
+		if (textAfter) {
+			yield fixer.insertTextAfter(returnStatement.argument, textAfter);
+		}
+
+		const returnStatementHasSemicolon = isSemicolonToken(sourceCode.getLastToken(returnStatement));
+		if (!returnStatementHasSemicolon) {
+			yield fixer.insertTextAfter(returnStatement, ';');
+		}
+
+		yield fixer.insertTextAfter(returnStatement, ' continue;');
+
+		if (insertBraces) {
+			yield fixer.insertTextAfter(returnStatement, ' }');
+		}
+	}
+
+	const shouldRemoveExpressionStatementLastToken = token => {
+		if (!isSemicolonToken(token)) {
+			return false;
+		}
+
+		if (callback.body.type !== 'BlockStatement') {
+			return false;
+		}
+
+		return true;
+	};
+
+	function * removeCallbackParentheses(fixer) {
+		// Opening parenthesis tokens already included in `getForOfLoopHeadRange`
+		const closingParenthesisTokens = getParentheses(callback, context)
+			.filter(token => isClosingParenToken(token));
+
+		for (const closingParenthesisToken of closingParenthesisTokens) {
+			yield fixer.remove(closingParenthesisToken);
+		}
+	}
+
+	return function * (fixer) {
+		// `(( foo.forEach(bar => bar) ))`
+		yield removeParentheses(callExpression, fixer, context);
+
+		// Replace these with `for (const … of …) `
+		// foo.forEach(bar =>    bar)
+		// ^^^^^^^^^^^^^^^^^^^^^^
+		// foo.forEach(bar =>    (bar))
+		// ^^^^^^^^^^^^^^^^^^^^^^
+		// foo.forEach(bar =>    {})
+		// ^^^^^^^^^^^^^^^^^^^^^^
+		// foo.forEach(function(bar)    {})
+		// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+		yield fixer.replaceTextRange(getForOfLoopHeadRange(), getForOfLoopHeadText());
+
+		// Parenthesized callback function
+		// foo.forEach( ((bar => {})) )
+		//                         ^^
+		yield removeCallbackParentheses(fixer);
+
+		const [
+			penultimateToken,
+			lastToken,
+		] = sourceCode.getLastTokens(callExpression, 2);
+
+		// The possible trailing comma token of `Array#forEach()` CallExpression
+		// foo.forEach(bar => {},)
+		//                      ^
+		if (isCommaToken(penultimateToken)) {
+			yield fixer.remove(penultimateToken);
+		}
+
+		// The closing parenthesis token of `Array#forEach()` CallExpression
+		// foo.forEach(bar => {})
+		//                      ^
+		yield fixer.remove(lastToken);
+
+		for (const returnStatement of returnStatements) {
+			yield replaceReturnStatement(returnStatement, fixer);
+		}
+
+		if (ancestor.type === 'ExpressionStatement') {
+			const expressionStatementLastToken = sourceCode.getLastToken(ancestor);
+			// Remove semicolon if it's not needed anymore
+			// foo.forEach(bar => {});
+			//                       ^
+			if (shouldRemoveExpressionStatementLastToken(expressionStatementLastToken)) {
+				yield fixer.remove(expressionStatementLastToken, fixer);
+			}
+		} else if (ancestor.type === 'ArrowFunctionExpression') {
+			yield fixer.insertTextBefore(callExpression, '{ ');
+			yield fixer.insertTextAfter(callExpression, ' }');
+		}
+
+		yield fixSpaceAroundKeyword(fixer, callExpression.parent, context);
+
+		if (isOptionalObject) {
+			yield fixer.insertTextBefore(callExpression, `if (${objectText}) `);
+		}
+
+		// Prevent possible variable conflicts
+		yield extendFixRange(fixer, sourceCode.getRange(callExpression.parent));
+	};
+}
+
+const isChildScope = (child, parent) => {
+	for (let scope = child; scope; scope = scope.upper) {
+		if (scope === parent) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+function isFunctionParametersSafeToFix(callbackFunction, {sourceCode, scope, callExpression, allIdentifiers}) {
+	const variables = sourceCode.getDeclaredVariables(callbackFunction);
+
+	for (const variable of variables) {
+		if (variable.defs.length !== 1) {
+			return false;
+		}
+
+		const [definition] = variable.defs;
+		if (definition.type !== 'Parameter') {
+			continue;
+		}
+
+		const variableName = definition.name.name;
+		const [callExpressionStart, callExpressionEnd] = sourceCode.getRange(callExpression);
+		for (const identifier of allIdentifiers) {
+			const {name} = identifier;
+			const [start, end] = sourceCode.getRange(identifier);
+			if (
+				name !== variableName
+				|| start < callExpressionStart
+				|| end > callExpressionEnd
+			) {
+				continue;
+			}
+
+			const variable = findVariable(scope, identifier);
+			if (!variable || variable.scope === scope || isChildScope(scope, variable.scope)) {
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+function isFunctionParameterVariableReassigned(callbackFunction, sourceCode) {
+	return sourceCode.getDeclaredVariables(callbackFunction)
+		.filter(variable => variable.defs[0].type === 'Parameter')
+		.some(variable =>
+			variable.references.some(reference => !reference.init && reference.isWrite()),
+		);
+}
+
+function isFixable(callExpression, {scope, functionInfo, allIdentifiers, sourceCode}) {
+	// Check `CallExpression`
+	if (callExpression.optional || callExpression.arguments.length !== 1) {
+		return false;
+	}
+
+	// Check ancestors, we only fix `ExpressionStatement`
+	const callOrChainExpression = stripChainExpression(callExpression);
+	if (
+		callOrChainExpression.parent.type !== 'ExpressionStatement'
+		&& !isArrowFunctionBody(callOrChainExpression)
+	) {
+		return false;
+	}
+
+	// Check `CallExpression.arguments[0]`;
+	const [callback] = callExpression.arguments;
+	if (
+		// Leave non-function type to `no-array-callback-reference` rule
+		(callback.type !== 'FunctionExpression' && callback.type !== 'ArrowFunctionExpression')
+		|| callback.async
+		|| callback.generator
+	) {
+		return false;
+	}
+
+	// Check `callback.params`
+	const parameters = callback.params;
+	if (
+		!(parameters.length === 1 || parameters.length === 2)
+		// `array.forEach((element = defaultValue) => {})`
+		|| (parameters.length === 1 && parameters[0].type === 'AssignmentPattern')
+		// https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1814
+		|| (parameters.length === 2 && parameters[1].type !== 'Identifier')
+		|| parameters.some(({type, typeAnnotation}) => type === 'RestElement' || typeAnnotation)
+		|| !isFunctionParametersSafeToFix(callback, {
+			scope,
+			callExpression,
+			allIdentifiers,
+			sourceCode,
+		})
+	) {
+		return false;
+	}
+
+	// Check `ReturnStatement`s in `callback`
+	const {returnStatements, scope: callbackScope} = functionInfo.get(callback);
+	if (returnStatements.some(returnStatement => isReturnStatementInContinueAbleNodes(returnStatement, callback))) {
+		return false;
+	}
+
+	if (isFunctionSelfUsedInside(callback, callbackScope)) {
+		return false;
+	}
+
+	return true;
+}
+
+const ignoredObjects = [
+	'React.Children',
+	'Children',
+	'R',
+	// https://www.npmjs.com/package/p-iteration
+	'pIteration',
+	// https://www.npmjs.com/package/effect
+	'Effect',
+];
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const functionStack = [];
+	const callExpressions = [];
+	const allIdentifiers = [];
+	const functionInfo = new Map();
+	const {sourceCode} = context;
+
+	context.on(functionTypes, node => {
+		functionStack.push(node);
+		functionInfo.set(node, {
+			returnStatements: [],
+			scope: sourceCode.getScope(node),
+		});
+	});
+
+	context.onExit(functionTypes, () => {
+		functionStack.pop();
+	});
+
+	context.on('Identifier', node => {
+		if (isReferenceIdentifier(node)) {
+			allIdentifiers.push(node);
+		}
+	});
+
+	context.on('ReturnStatement', node => {
+		const currentFunction = functionStack.at(-1);
+		if (!currentFunction) {
+			return;
+		}
+
+		const {returnStatements} = functionInfo.get(currentFunction);
+		returnStatements.push(node);
+	});
+
+	context.on('CallExpression', node => {
+		if (
+			!isMethodCall(node, {
+				method: 'forEach',
+			})
+			|| isNodeMatches(node.callee.object, ignoredObjects)
+		) {
+			return;
+		}
+
+		callExpressions.push({
+			node,
+			scope: sourceCode.getScope(node),
+		});
+	});
+
+	context.onExit('Program', function * () {
+		for (const {node, scope} of callExpressions) {
+			const iterable = node.callee;
+
+			const problem = {
+				node: iterable.property,
+				messageId: MESSAGE_ID_ERROR,
+			};
+
+			if (!isFixable(node, {
+				scope,
+				allIdentifiers,
+				functionInfo,
+				sourceCode,
+			})) {
+				yield problem;
+				continue;
+			}
+
+			const shouldUseSuggestion = iterable.optional && hasSideEffect(iterable, sourceCode);
+			const fix = getFixFunction(node, functionInfo, context);
+
+			if (shouldUseSuggestion) {
+				problem.suggest = [
+					{
+						messageId: MESSAGE_ID_SUGGESTION,
+						fix,
+					},
+				];
+			} else {
+				problem.fix = fix;
+			}
+
+			yield problem;
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `for…of` over the `forEach` method.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-array-method-this-argument.js

@@ -0,0 +1,223 @@
+import {hasSideEffect} from '@eslint-community/eslint-utils';
+import {removeArgument} from './fix/index.js';
+import {getParentheses, getParenthesizedText} from './utils/parentheses.js';
+import shouldAddParenthesesToMemberExpressionObject from './utils/should-add-parentheses-to-member-expression-object.js';
+import {isNodeMatches} from './utils/is-node-matches.js';
+import {isNodeValueNotFunction} from './utils/index.js';
+import {isMethodCall} from './ast/index.js';
+
+const ERROR_PROTOTYPE_METHOD = 'error-prototype-method';
+const ERROR_STATIC_METHOD = 'error-static-method';
+const SUGGESTION_BIND = 'suggestion-bind';
+const SUGGESTION_REMOVE = 'suggestion-remove';
+const messages = {
+	[ERROR_PROTOTYPE_METHOD]: 'Do not use the `this` argument in `Array#{{method}}()`.',
+	[ERROR_STATIC_METHOD]: 'Do not use the `this` argument in `Array.{{method}}()`.',
+	[SUGGESTION_REMOVE]: 'Remove this argument.',
+	[SUGGESTION_BIND]: 'Use a bound function.',
+};
+
+const ignored = [
+	'lodash.every',
+	'_.every',
+	'underscore.every',
+
+	'lodash.filter',
+	'_.filter',
+	'underscore.filter',
+	'Vue.filter',
+	'R.filter',
+
+	'lodash.find',
+	'_.find',
+	'underscore.find',
+	'R.find',
+
+	'lodash.findLast',
+	'_.findLast',
+	'underscore.findLast',
+	'R.findLast',
+
+	'lodash.findIndex',
+	'_.findIndex',
+	'underscore.findIndex',
+	'R.findIndex',
+
+	'lodash.findLastIndex',
+	'_.findLastIndex',
+	'underscore.findLastIndex',
+	'R.findLastIndex',
+
+	'lodash.flatMap',
+	'_.flatMap',
+
+	'lodash.forEach',
+	'_.forEach',
+	'React.Children.forEach',
+	'Children.forEach',
+	'R.forEach',
+
+	'lodash.map',
+	'_.map',
+	'underscore.map',
+	'React.Children.map',
+	'Children.map',
+	'jQuery.map',
+	'$.map',
+	'R.map',
+
+	'lodash.some',
+	'_.some',
+	'underscore.some',
+];
+
+function removeThisArgument(thisArgumentNode, context) {
+	return fixer => removeArgument(fixer, thisArgumentNode, context);
+}
+
+function useBoundFunction(callbackNode, thisArgumentNode, context) {
+	return function * (fixer) {
+		yield removeThisArgument(thisArgumentNode, context)(fixer);
+
+		const callbackParentheses = getParentheses(callbackNode, context);
+		const isParenthesized = callbackParentheses.length > 0;
+		const callbackLastToken = isParenthesized
+			? callbackParentheses.at(-1)
+			: callbackNode;
+		if (
+			!isParenthesized
+			&& shouldAddParenthesesToMemberExpressionObject(callbackNode, context)
+		) {
+			yield fixer.insertTextBefore(callbackLastToken, '(');
+			yield fixer.insertTextAfter(callbackLastToken, ')');
+		}
+
+		const thisArgumentText = getParenthesizedText(thisArgumentNode, context);
+		// `thisArgument` was a argument, no need add extra parentheses
+		yield fixer.insertTextAfter(callbackLastToken, `.bind(${thisArgumentText})`);
+	};
+}
+
+function getProblem({
+	context,
+	callExpression,
+	callbackNode,
+	thisArgumentNode,
+	messageId,
+}) {
+	const problem = {
+		node: thisArgumentNode,
+		messageId,
+		data: {
+			method: callExpression.callee.property.name,
+		},
+	};
+
+	const isArrowCallback = callbackNode.type === 'ArrowFunctionExpression';
+	if (isArrowCallback) {
+		const thisArgumentHasSideEffect = hasSideEffect(thisArgumentNode, context.sourceCode);
+		if (thisArgumentHasSideEffect) {
+			problem.suggest = [
+				{
+					messageId: SUGGESTION_REMOVE,
+					fix: removeThisArgument(thisArgumentNode, context),
+				},
+			];
+		} else {
+			problem.fix = removeThisArgument(thisArgumentNode, context);
+		}
+
+		return problem;
+	}
+
+	problem.suggest = [
+		{
+			messageId: SUGGESTION_REMOVE,
+			fix: removeThisArgument(thisArgumentNode, context),
+		},
+		{
+			messageId: SUGGESTION_BIND,
+			fix: useBoundFunction(callbackNode, thisArgumentNode, context),
+		},
+	];
+
+	return problem;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	// Prototype methods
+	context.on('CallExpression', callExpression => {
+		if (
+			!isMethodCall(callExpression, {
+				methods: [
+					'every',
+					'filter',
+					'find',
+					'findLast',
+					'findIndex',
+					'findLastIndex',
+					'flatMap',
+					'forEach',
+					'map',
+					'some',
+				],
+				argumentsLength: 2,
+				optionalCall: false,
+			})
+			|| isNodeMatches(callExpression.callee, ignored)
+			|| isNodeValueNotFunction(callExpression.arguments[0])
+		) {
+			return;
+		}
+
+		return getProblem({
+			context,
+			callExpression,
+			callbackNode: callExpression.arguments[0],
+			thisArgumentNode: callExpression.arguments[1],
+			messageId: ERROR_PROTOTYPE_METHOD,
+		});
+	});
+
+	// `Array.from()` and `Array.fromAsync()`
+	context.on('CallExpression', callExpression => {
+		if (
+			!isMethodCall(callExpression, {
+				object: 'Array',
+				methods: ['from', 'fromAsync'],
+				argumentsLength: 3,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			|| isNodeValueNotFunction(callExpression.arguments[1])
+		) {
+			return;
+		}
+
+		return getProblem({
+			context,
+			callExpression,
+			callbackNode: callExpression.arguments[1],
+			thisArgumentNode: callExpression.arguments[2],
+			messageId: ERROR_STATIC_METHOD,
+		});
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow using the `this` argument in array methods.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;