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

package/rules/prefer-object-from-entries.js

@@ -0,0 +1,252 @@
+'use strict';
+const {isCommaToken, isArrowToken, isClosingParenToken} = require('@eslint-community/eslint-utils');
+const {isMethodCall, isLiteral} = require('./ast/index.js');
+const {removeParentheses} = require('./fix/index.js');
+const {
+	getParentheses,
+	getParenthesizedText,
+	isNodeMatchesNameOrPath,
+	isSameIdentifier,
+} = require('./utils/index.js');
+const {isCallExpression} = require('./ast/call-or-new-expression.js');
+
+const MESSAGE_ID_REDUCE = 'reduce';
+const MESSAGE_ID_FUNCTION = 'function';
+const messages = {
+	[MESSAGE_ID_REDUCE]: 'Prefer `Object.fromEntries()` over `Array#reduce()`.',
+	[MESSAGE_ID_FUNCTION]: 'Prefer `Object.fromEntries()` over `{{functionName}}()`.',
+};
+
+const isEmptyObject = node =>
+	// `{}`
+	(node.type === 'ObjectExpression' && node.properties.length === 0)
+	// `Object.create(null)`
+	|| (
+		isMethodCall(node, {
+			object: 'Object',
+			method: 'create',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})
+		// eslint-disable-next-line unicorn/no-null
+		&& isLiteral(node.arguments[0], null)
+	);
+
+const isArrowFunctionCallback = node =>
+	node.type === 'ArrowFunctionExpression'
+	&& !node.async
+	&& node.params.length > 0
+	&& node.params[0].type === 'Identifier';
+
+const isProperty = node =>
+	node.type === 'Property'
+	&& node.kind === 'init'
+	&& !node.method;
+
+// - `pairs.reduce(…, {})`
+// - `pairs.reduce(…, Object.create(null))`
+const isArrayReduceWithEmptyObject = node =>
+	isMethodCall(node, {
+		method: 'reduce',
+		argumentsLength: 2,
+		optionalCall: false,
+		optionalMember: false,
+	})
+	&& isEmptyObject(node.arguments[1]);
+
+const fixableArrayReduceCases = [
+	{
+		test: callExpression =>
+			isArrayReduceWithEmptyObject(callExpression)
+			// `() => Object.assign(object, {key})`
+			&& isArrowFunctionCallback(callExpression.arguments[0])
+			&& isMethodCall(callExpression.arguments[0].body, {
+				object: 'Object',
+				method: 'assign',
+				argumentsLength: 2,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& callExpression.arguments[0].body.arguments[1].type === 'ObjectExpression'
+			&& callExpression.arguments[0].body.arguments[1].properties.length === 1
+			&& isProperty(callExpression.arguments[0].body.arguments[1].properties[0])
+			&& isSameIdentifier(callExpression.arguments[0].params[0], callExpression.arguments[0].body.arguments[0]),
+		getProperty: callback => callback.body.arguments[1].properties[0],
+	},
+	{
+		test: callExpression =>
+			isArrayReduceWithEmptyObject(callExpression)
+			// `() => ({...object, key})`
+			&& isArrowFunctionCallback(callExpression.arguments[0])
+			&& callExpression.arguments[0].body.type === 'ObjectExpression'
+			&& callExpression.arguments[0].body.properties.length === 2
+			&& callExpression.arguments[0].body.properties[0].type === 'SpreadElement'
+			&& isProperty(callExpression.arguments[0].body.properties[1])
+			&& isSameIdentifier(callExpression.arguments[0].params[0], callExpression.arguments[0].body.properties[0].argument),
+		getProperty: callback => callback.body.properties[1],
+	},
+];
+
+// `_.flatten(array)`
+const lodashFromPairsFunctions = [
+	'_.fromPairs',
+	'lodash.fromPairs',
+];
+
+function fixReduceAssignOrSpread({sourceCode, callExpression, property}) {
+	const removeInitObject = fixer => {
+		const initObject = callExpression.arguments[1];
+		const parentheses = getParentheses(initObject, sourceCode);
+		const firstToken = parentheses[0] || initObject;
+		const lastToken = parentheses.at(-1) || initObject;
+		const startToken = sourceCode.getTokenBefore(firstToken);
+		const [start] = startToken.range;
+		const [, end] = lastToken.range;
+		return fixer.replaceTextRange([start, end], '');
+	};
+
+	function * removeFirstParameter(fixer) {
+		const parameters = callExpression.arguments[0].params;
+		const [firstParameter] = parameters;
+		const tokenAfter = sourceCode.getTokenAfter(firstParameter);
+
+		if (isCommaToken(tokenAfter)) {
+			yield fixer.remove(tokenAfter);
+		}
+
+		let shouldAddParentheses = false;
+		if (parameters.length === 1) {
+			const arrowToken = sourceCode.getTokenAfter(firstParameter, isArrowToken);
+			const tokenBeforeArrowToken = sourceCode.getTokenBefore(arrowToken);
+
+			if (!isClosingParenToken(tokenBeforeArrowToken)) {
+				shouldAddParentheses = true;
+			}
+		}
+
+		yield fixer.replaceText(firstParameter, shouldAddParentheses ? '()' : '');
+	}
+
+	const getKeyValueText = () => {
+		const {key, value} = property;
+		let keyText = getParenthesizedText(key, sourceCode);
+		const valueText = getParenthesizedText(value, sourceCode);
+
+		if (!property.computed && key.type === 'Identifier') {
+			keyText = `'${keyText}'`;
+		}
+
+		return {keyText, valueText};
+	};
+
+	function * replaceFunctionBody(fixer) {
+		const functionBody = callExpression.arguments[0].body;
+		const {keyText, valueText} = getKeyValueText();
+		yield fixer.replaceText(functionBody, `[${keyText}, ${valueText}]`);
+		yield * removeParentheses(functionBody, fixer, sourceCode);
+	}
+
+	return function * (fixer) {
+		// Wrap `array.reduce()` with `Object.fromEntries()`
+		yield fixer.insertTextBefore(callExpression, 'Object.fromEntries(');
+		yield fixer.insertTextAfter(callExpression, ')');
+
+		// Switch `.reduce` to `.map`
+		yield fixer.replaceText(callExpression.callee.property, 'map');
+
+		// Remove empty object
+		yield removeInitObject(fixer);
+
+		// Remove the first parameter
+		yield * removeFirstParameter(fixer);
+
+		// Replace function body
+		yield * replaceFunctionBody(fixer);
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+function create(context) {
+	const {sourceCode} = context;
+	const {functions: configFunctions} = {
+		functions: [],
+		...context.options[0],
+	};
+	const functions = [...configFunctions, ...lodashFromPairsFunctions];
+
+	return {
+		* CallExpression(callExpression) {
+			for (const {test, getProperty} of fixableArrayReduceCases) {
+				if (!test(callExpression)) {
+					continue;
+				}
+
+				const [callbackFunction] = callExpression.arguments;
+				const [firstParameter] = callbackFunction.params;
+				const variables = sourceCode.getDeclaredVariables(callbackFunction);
+				const firstParameterVariable = variables.find(variable => variable.identifiers.length === 1 && variable.identifiers[0] === firstParameter);
+				if (!firstParameterVariable || firstParameterVariable.references.length !== 1) {
+					continue;
+				}
+
+				yield {
+					node: callExpression.callee.property,
+					messageId: MESSAGE_ID_REDUCE,
+					fix: fixReduceAssignOrSpread({
+						sourceCode,
+						callExpression,
+						property: getProperty(callbackFunction),
+					}),
+				};
+			}
+
+			if (!isCallExpression(callExpression, {
+				argumentsLength: 1,
+				optional: false,
+			})) {
+				return;
+			}
+
+			const functionNode = callExpression.callee;
+			for (const nameOrPath of functions) {
+				const functionName = nameOrPath.trim();
+				if (isNodeMatchesNameOrPath(functionNode, functionName)) {
+					yield {
+						node: functionNode,
+						messageId: MESSAGE_ID_FUNCTION,
+						data: {functionName},
+						fix: fixer => fixer.replaceText(functionNode, 'Object.fromEntries'),
+					};
+				}
+			}
+		},
+	};
+}
+
+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 using `Object.fromEntries(…)` to transform a list of key-value pairs into an object.',
+		},
+		fixable: 'code',
+		schema,
+		messages,
+	},
+};

package/rules/prefer-optional-catch-binding.js

@@ -0,0 +1,75 @@
+'use strict';
+const {isOpeningParenToken, isClosingParenToken} = require('@eslint-community/eslint-utils');
+const assertToken = require('./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] = tokenAfter.range;
+				const [startOfCatchClauseBody] = parent.body.range;
+				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} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer omitting the `catch` binding parameter.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-prototype-methods.js

@@ -0,0 +1,88 @@
+'use strict';
+const {getPropertyName} = require('@eslint-community/eslint-utils');
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+const {isMemberExpression, isMethodCall} = require('./ast/index.js');
+
+const messages = {
+	'known-method': 'Prefer using `{{constructorName}}.prototype.{{methodName}}`.',
+	'unknown-method': 'Prefer using method from `{{constructorName}}.prototype`.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+function create(context) {
+	return {
+		CallExpression(callExpression) {
+			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;
+			}
+
+			if (!methodNode || !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 {sourceCode} = context;
+			const methodName = getPropertyName(methodNode, sourceCode.getScope(methodNode));
+
+			return {
+				node: methodNode,
+				messageId: methodName ? 'known-method' : 'unknown-method',
+				data: {constructorName, methodName},
+				* fix(fixer) {
+					yield fixer.replaceText(objectNode, `${constructorName}.prototype`);
+
+					if (
+						objectNode.type === 'ArrayExpression'
+						|| objectNode.type === 'ObjectExpression'
+					) {
+						yield * fixSpaceAroundKeyword(fixer, callExpression, sourceCode);
+					}
+				},
+			};
+		},
+	};
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer borrowing methods from the prototype instead of the instance.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-query-selector.js

@@ -0,0 +1,135 @@
+'use strict';
+const {isNodeValueNotDomNode} = require('./utils/index.js');
+const {isMethodCall, isStringLiteral, isNullLiteral} = require('./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'],
+]);
+
+const getReplacementForId = value => `#${value}`;
+const getReplacementForClass = value => value.match(/\S+/g).map(className => `.${className}`).join('');
+
+const getQuotedReplacement = (node, value) => {
+	const leftQuote = node.raw.charAt(0);
+	const rightQuote = node.raw.at(-1);
+	return `${leftQuote}${value}${rightQuote}`;
+};
+
+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));
+	}
+
+	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),
+			);
+		}
+	}
+}
+
+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'],
+				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} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()`.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-reflect-apply.js

@@ -0,0 +1,97 @@
+'use strict';
+const {getPropertyName} = require('@eslint-community/eslint-utils');
+const {isNullLiteral, isMethodCall} = require('./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} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `Reflect.apply()` over `Function#apply()`.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};