eslint-plugin-unicorn-ts 0.0.1-security → 50.0.1

package/rules/prefer-array-flat.js

@@ -0,0 +1,279 @@
+'use strict';
+const {
+	getParenthesizedText,
+	isArrayPrototypeProperty,
+	isNodeMatches,
+	isNodeMatchesNameOrPath,
+	isParenthesized,
+	isSameIdentifier,
+	needsSemicolon,
+	shouldAddParenthesesToMemberExpressionObject,
+} = require('./utils/index.js');
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+const {
+	isMethodCall,
+	isCallExpression,
+} = require('./ast/index.js');
+
+const MESSAGE_ID = 'prefer-array-flat';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `Array#flat()` over `{{description}}` to flatten an array.',
+};
+
+const isEmptyArrayExpression = node =>
+	node.type === 'ArrayExpression'
+	&& node.elements.length === 0;
+
+// `array.flatMap(x => x)`
+const arrayFlatMap = {
+	testFunction(node) {
+		if (!isMethodCall(node, {
+			method: 'flatMap',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: 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,
+	description: 'Array#flatMap()',
+};
+
+// `array.reduce((a, b) => a.concat(b), [])`
+// `array.reduce((a, b) => [...a, ...b], [])`
+const arrayReduce = {
+	testFunction(node) {
+		if (!isMethodCall(node, {
+			method: 'reduce',
+			argumentsLength: 2,
+			optionalCall: false,
+			optionalMember: 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,
+	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, sourceCode, shouldSwitchToArray) {
+	if (typeof shouldSwitchToArray === 'function') {
+		shouldSwitchToArray = shouldSwitchToArray(node);
+	}
+
+	return function * (fixer) {
+		let fixed = getParenthesizedText(array, sourceCode);
+		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, sourceCode)
+		) {
+			fixed = `(${fixed})`;
+		}
+
+		fixed = `${fixed}.flat()`;
+
+		const tokenBefore = sourceCode.getTokenBefore(node);
+		if (needsSemicolon(tokenBefore, sourceCode, fixed)) {
+			fixed = `;${fixed}`;
+		}
+
+		yield fixer.replaceText(node, fixed);
+
+		yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
+	};
+}
+
+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} of cases) {
+				if (!testFunction(node)) {
+					continue;
+				}
+
+				const array = getArrayNode(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, sourceCode, shouldSwitchToArray);
+				}
+
+				yield problem;
+			}
+		},
+	};
+}
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			functions: {
+				type: 'array',
+				uniqueItems: true,
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `Array#flat()` over legacy techniques to flatten arrays.',
+		},
+		fixable: 'code',
+		schema,
+		messages,
+	},
+};

package/rules/prefer-array-index-of.js

@@ -0,0 +1,32 @@
+'use strict';
+const simpleArraySearchRule = require('./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} */
+module.exports = {
+	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.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages: {
+			...indexOfOverFindIndexRule.messages,
+			...lastIndexOfOverFindLastIndexRule.messages,
+		},
+	},
+};

package/rules/prefer-array-some.js

@@ -0,0 +1,157 @@
+'use strict';
+const {checkVueTemplate} = require('./utils/rule.js');
+const {
+	isBooleanNode,
+	getParenthesizedRange,
+	isNodeValueNotFunction,
+} = require('./utils/index.js');
+const {removeMemberExpressionProperty} = require('./fix/index.js');
+const {isLiteral, isUndefined, isMethodCall, isMemberExpression} = require('./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)
+		)
+	);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	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 parenthesizedRange = getParenthesizedRange(callExpression, context.sourceCode);
+						yield fixer.replaceTextRange([parenthesizedRange[1], callExpression.parent.range[1]], '');
+
+						if (callExpression.parent.operator === '!=' || callExpression.parent.operator === '!==') {
+							return;
+						}
+
+						yield fixer.insertTextBeforeRange(parenthesizedRange, '!');
+					},
+				},
+			],
+		};
+	},
+	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, sourceCode);
+
+				/*
+					Remove `> 0`
+					`(( (( array.filter() )).length )) > (( 0 ))`
+					----------------------------------^^^^^^^^^^
+				*/
+				yield fixer.removeRange([
+					getParenthesizedRange(lengthNode, sourceCode)[1],
+					binaryExpression.range[1],
+				]);
+
+				// The `BinaryExpression` always ends with a number or `)`, no need check for ASI
+			},
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create: checkVueTemplate(create),
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast}(…)`.',
+		},
+		fixable: 'code',
+		messages,
+		hasSuggestions: true,
+	},
+};