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

package/rules/no-keyword-prefix.js

@@ -0,0 +1,199 @@
+'use strict';
+const isShorthandPropertyAssignmentPatternLeft = require('./utils/is-shorthand-property-assignment-pattern-left.js');
+
+const MESSAGE_ID = 'noKeywordPrefix';
+const messages = {
+	[MESSAGE_ID]: 'Do not prefix identifiers with keyword `{{keyword}}`.',
+};
+
+const prepareOptions = ({
+	disallowedPrefixes,
+	checkProperties = true,
+	onlyCamelCase = true,
+} = {}) => ({
+	disallowedPrefixes: (disallowedPrefixes || [
+		'new',
+		'class',
+	]),
+	checkProperties,
+	onlyCamelCase,
+});
+
+function findKeywordPrefix(name, options) {
+	return options.disallowedPrefixes.find(keyword => {
+		const suffix = options.onlyCamelCase ? '[A-Z]' : '.';
+		const regex = new RegExp(`^${keyword}${suffix}`);
+		return name.match(regex);
+	});
+}
+
+function checkMemberExpression(report, node, options) {
+	const {name, parent} = node;
+	const keyword = findKeywordPrefix(name, options);
+	const effectiveParent = parent.type === 'MemberExpression' ? parent.parent : parent;
+
+	if (!options.checkProperties) {
+		return;
+	}
+
+	if (parent.object.type === 'Identifier' && parent.object.name === name && Boolean(keyword)) {
+		report(node, keyword);
+	} else if (
+		effectiveParent.type === 'AssignmentExpression'
+		&& Boolean(keyword)
+		&& (effectiveParent.right.type !== 'MemberExpression' || effectiveParent.left.type === 'MemberExpression')
+		&& effectiveParent.left.property.name === name
+	) {
+		report(node, keyword);
+	}
+}
+
+function checkObjectPattern(report, node, options) {
+	const {name, parent} = node;
+	const keyword = findKeywordPrefix(name, options);
+
+	/* c8 ignore next 3 */
+	if (parent.shorthand && parent.value.left && Boolean(keyword)) {
+		report(node, keyword);
+	}
+
+	const assignmentKeyEqualsValue = parent.key.name === parent.value.name;
+
+	if (Boolean(keyword) && parent.computed) {
+		report(node, keyword);
+	}
+
+	// Prevent checking right hand side of destructured object
+	if (parent.key === node && parent.value !== node) {
+		return true;
+	}
+
+	const valueIsInvalid = parent.value.name && Boolean(keyword);
+
+	// Ignore destructuring if the option is set, unless a new identifier is created
+	if (valueIsInvalid && !assignmentKeyEqualsValue) {
+		report(node, keyword);
+	}
+
+	return false;
+}
+
+// Core logic copied from:
+// https://github.com/eslint/eslint/blob/master/lib/rules/camelcase.js
+const create = context => {
+	const options = prepareOptions(context.options[0]);
+
+	// Contains reported nodes to avoid reporting twice on destructuring with shorthand notation
+	const reported = [];
+	const ALLOWED_PARENT_TYPES = new Set(['CallExpression', 'NewExpression']);
+
+	function report(node, keyword) {
+		if (!reported.includes(node)) {
+			reported.push(node);
+			context.report({
+				node,
+				messageId: MESSAGE_ID,
+				data: {
+					name: node.name,
+					keyword,
+				},
+			});
+		}
+	}
+
+	return {
+		Identifier(node) {
+			const {name, parent} = node;
+			const keyword = findKeywordPrefix(name, options);
+			const effectiveParent = parent.type === 'MemberExpression' ? parent.parent : parent;
+
+			if (parent.type === 'MemberExpression') {
+				checkMemberExpression(report, node, options);
+			} else if (
+				parent.type === 'Property'
+				|| parent.type === 'AssignmentPattern'
+			) {
+				if (parent.parent.type === 'ObjectPattern') {
+					const finished = checkObjectPattern(report, node, options);
+					if (finished) {
+						return;
+					}
+				}
+
+				if (
+					!options.checkProperties
+				) {
+					return;
+				}
+
+				// Don't check right hand side of AssignmentExpression to prevent duplicate warnings
+				if (
+					Boolean(keyword)
+					&& !ALLOWED_PARENT_TYPES.has(effectiveParent.type)
+					&& !(parent.right === node)
+					&& !isShorthandPropertyAssignmentPatternLeft(node)
+				) {
+					report(node, keyword);
+				}
+
+			// Check if it's an import specifier
+			} else if (
+				[
+					'ImportSpecifier',
+					'ImportNamespaceSpecifier',
+					'ImportDefaultSpecifier',
+				].includes(parent.type)
+			) {
+				// Report only if the local imported identifier is invalid
+				if (Boolean(keyword) && parent.local?.name === name) {
+					report(node, keyword);
+				}
+
+			// Report anything that is invalid that isn't a CallExpression
+			} else if (
+				Boolean(keyword)
+				&& !ALLOWED_PARENT_TYPES.has(effectiveParent.type)
+			) {
+				report(node, keyword);
+			}
+		},
+	};
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			disallowedPrefixes: {
+				type: 'array',
+				items: [
+					{
+						type: 'string',
+					},
+				],
+				minItems: 0,
+				uniqueItems: true,
+			},
+			checkProperties: {
+				type: 'boolean',
+			},
+			onlyCamelCase: {
+				type: 'boolean',
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow identifiers starting with `new` or `class`.',
+		},
+		schema,
+		messages,
+	},
+};

package/rules/no-lonely-if.js

@@ -0,0 +1,151 @@
+'use strict';
+const {isParenthesized, isNotSemicolonToken} = require('@eslint-community/eslint-utils');
+const {needsSemicolon} = require('./utils/index.js');
+const {removeSpacesAfter} = require('./fix/index.js');
+
+const MESSAGE_ID = 'no-lonely-if';
+const messages = {
+	[MESSAGE_ID]: 'Unexpected `if` as the only statement in a `if` block without `else`.',
+};
+
+const isIfStatementWithoutAlternate = node => node.type === 'IfStatement' && !node.alternate;
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table
+// Lower precedence than `&&`
+const needParenthesis = node => (
+	(node.type === 'LogicalExpression' && (node.operator === '||' || node.operator === '??'))
+	|| node.type === 'ConditionalExpression'
+	|| node.type === 'AssignmentExpression'
+	|| node.type === 'YieldExpression'
+	|| node.type === 'SequenceExpression'
+);
+
+function getIfStatementTokens(node, sourceCode) {
+	const tokens = {};
+
+	tokens.ifToken = sourceCode.getFirstToken(node);
+	tokens.openingParenthesisToken = sourceCode.getFirstToken(node, 1);
+
+	const {consequent} = node;
+	tokens.closingParenthesisToken = sourceCode.getTokenBefore(consequent);
+
+	if (consequent.type === 'BlockStatement') {
+		tokens.openingBraceToken = sourceCode.getFirstToken(consequent);
+		tokens.closingBraceToken = sourceCode.getLastToken(consequent);
+	}
+
+	return tokens;
+}
+
+function fix(innerIfStatement, sourceCode) {
+	return function * (fixer) {
+		const outerIfStatement = (
+			innerIfStatement.parent.type === 'BlockStatement'
+				? innerIfStatement.parent
+				: innerIfStatement
+		).parent;
+		const outer = {
+			...outerIfStatement,
+			...getIfStatementTokens(outerIfStatement, sourceCode),
+		};
+		const inner = {
+			...innerIfStatement,
+			...getIfStatementTokens(innerIfStatement, sourceCode),
+		};
+
+		// Remove inner `if` token
+		yield fixer.remove(inner.ifToken);
+		yield removeSpacesAfter(inner.ifToken, sourceCode, fixer);
+
+		// Remove outer `{}`
+		if (outer.openingBraceToken) {
+			yield fixer.remove(outer.openingBraceToken);
+			yield removeSpacesAfter(outer.openingBraceToken, sourceCode, fixer);
+			yield fixer.remove(outer.closingBraceToken);
+
+			const tokenBefore = sourceCode.getTokenBefore(outer.closingBraceToken, {includeComments: true});
+			yield removeSpacesAfter(tokenBefore, sourceCode, fixer);
+		}
+
+		// Add new `()`
+		yield fixer.insertTextBefore(outer.openingParenthesisToken, '(');
+		yield fixer.insertTextAfter(
+			inner.closingParenthesisToken,
+			`)${inner.consequent.type === 'EmptyStatement' ? '' : ' '}`,
+		);
+
+		// Add ` && `
+		yield fixer.insertTextAfter(outer.closingParenthesisToken, ' && ');
+
+		// Remove `()` if `test` don't need it
+		for (const {test, openingParenthesisToken, closingParenthesisToken} of [outer, inner]) {
+			if (
+				isParenthesized(test, sourceCode)
+				|| !needParenthesis(test)
+			) {
+				yield fixer.remove(openingParenthesisToken);
+				yield fixer.remove(closingParenthesisToken);
+			}
+
+			yield removeSpacesAfter(closingParenthesisToken, sourceCode, fixer);
+		}
+
+		// If the `if` statement has no block, and is not followed by a semicolon,
+		// make sure that fixing the issue would not change semantics due to ASI.
+		// Similar logic https://github.com/eslint/eslint/blob/2124e1b5dad30a905dc26bde9da472bf622d3f50/lib/rules/no-lonely-if.js#L61-L77
+		if (inner.consequent.type !== 'BlockStatement') {
+			const lastToken = sourceCode.getLastToken(inner.consequent);
+			if (isNotSemicolonToken(lastToken)) {
+				const nextToken = sourceCode.getTokenAfter(outer);
+				if (nextToken && needsSemicolon(lastToken, sourceCode, nextToken.value)) {
+					yield fixer.insertTextBefore(nextToken, ';');
+				}
+			}
+		}
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	IfStatement(ifStatement) {
+		if (!(
+			isIfStatementWithoutAlternate(ifStatement)
+			&& (
+				// `if (a) { if (b) {} }`
+				(
+					ifStatement.parent.type === 'BlockStatement'
+					&& ifStatement.parent.body.length === 1
+					&& ifStatement.parent.body[0] === ifStatement
+					&& isIfStatementWithoutAlternate(ifStatement.parent.parent)
+					&& ifStatement.parent.parent.consequent === ifStatement.parent
+				)
+				// `if (a) if (b) {}`
+				|| (
+					isIfStatementWithoutAlternate(ifStatement.parent)
+					&& ifStatement.parent.consequent === ifStatement
+				)
+			)
+		)) {
+			return;
+		}
+
+		return {
+			node: ifStatement,
+			messageId: MESSAGE_ID,
+			fix: fix(ifStatement, context.sourceCode),
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow `if` statements as the only statement in `if` blocks without `else`.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-negated-condition.js

@@ -0,0 +1,144 @@
+/*
+Based on ESLint builtin `no-negated-condition` rule
+https://github.com/eslint/eslint/blob/5c39425fc55ecc0b97bbd07ac22654c0eb4f789c/lib/rules/no-negated-condition.js
+*/
+'use strict';
+const {
+	removeParentheses,
+	fixSpaceAroundKeyword,
+	addParenthesizesToReturnOrThrowExpression,
+} = require('./fix/index.js');
+const {
+	getParenthesizedRange,
+	isParenthesized,
+} = require('./utils/parentheses.js');
+const isOnSameLine = require('./utils/is-on-same-line.js');
+const needsSemicolon = require('./utils/needs-semicolon.js');
+
+const MESSAGE_ID = 'no-negated-condition';
+const messages = {
+	[MESSAGE_ID]: 'Unexpected negated condition.',
+};
+
+function * convertNegatedCondition(fixer, node, sourceCode) {
+	const {test} = node;
+	if (test.type === 'UnaryExpression') {
+		const token = sourceCode.getFirstToken(test);
+
+		if (node.type === 'IfStatement') {
+			yield * removeParentheses(test.argument, fixer, sourceCode);
+		}
+
+		yield fixer.remove(token);
+		return;
+	}
+
+	const token = sourceCode.getTokenAfter(
+		test.left,
+		token => token.type === 'Punctuator' && token.value === test.operator,
+	);
+
+	yield fixer.replaceText(token, '=' + token.value.slice(1));
+}
+
+function * swapConsequentAndAlternate(fixer, node, sourceCode) {
+	const isIfStatement = node.type === 'IfStatement';
+	const [consequent, alternate] = [
+		node.consequent,
+		node.alternate,
+	].map(node => {
+		const range = getParenthesizedRange(node, sourceCode);
+		let text = sourceCode.text.slice(...range);
+		// `if (!a) b(); else c()` can't fix to `if (!a) c() else b();`
+		if (isIfStatement && node.type !== 'BlockStatement') {
+			text = `{${text}}`;
+		}
+
+		return {
+			range,
+			text,
+		};
+	});
+
+	if (consequent.text === alternate.text) {
+		return;
+	}
+
+	yield fixer.replaceTextRange(consequent.range, alternate.text);
+	yield fixer.replaceTextRange(alternate.range, consequent.text);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on(['IfStatement', 'ConditionalExpression'], node => {
+		if (
+			node.type === 'IfStatement'
+			&& (
+				!node.alternate
+				|| node.alternate.type === 'IfStatement'
+			)
+		) {
+			return;
+		}
+
+		const {test} = node;
+
+		if (!(
+			(test.type === 'UnaryExpression' && test.operator === '!')
+			|| (test.type === 'BinaryExpression' && (test.operator === '!=' || test.operator === '!=='))
+		)) {
+			return;
+		}
+
+		return {
+			node: test,
+			messageId: MESSAGE_ID,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			* fix(fixer) {
+				const {sourceCode} = context;
+				yield * convertNegatedCondition(fixer, node, sourceCode);
+				yield * swapConsequentAndAlternate(fixer, node, sourceCode);
+
+				if (
+					node.type !== 'ConditionalExpression'
+					|| test.type !== 'UnaryExpression'
+				) {
+					return;
+				}
+
+				yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
+
+				const {parent} = node;
+				const [firstToken, secondToken] = sourceCode.getFirstTokens(test, 2);
+				if (
+					(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
+					&& parent.argument === node
+					&& !isOnSameLine(firstToken, secondToken)
+					&& !isParenthesized(node, sourceCode)
+					&& !isParenthesized(test, sourceCode)
+				) {
+					yield * addParenthesizesToReturnOrThrowExpression(fixer, parent, sourceCode);
+					return;
+				}
+
+				const tokenBefore = sourceCode.getTokenBefore(node);
+				if (needsSemicolon(tokenBefore, sourceCode, secondToken.value)) {
+					yield fixer.insertTextBefore(node, ';');
+				}
+			},
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow negated conditions.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-nested-ternary.js

@@ -0,0 +1,58 @@
+'use strict';
+const {isParenthesized} = require('@eslint-community/eslint-utils');
+
+const MESSAGE_ID_TOO_DEEP = 'too-deep';
+const MESSAGE_ID_SHOULD_PARENTHESIZED = 'should-parenthesized';
+const messages = {
+	[MESSAGE_ID_TOO_DEEP]: 'Do not nest ternary expressions.',
+	[MESSAGE_ID_SHOULD_PARENTHESIZED]: 'Nest ternary expression should be parenthesized.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	ConditionalExpression(node) {
+		if ([
+			node.test,
+			node.consequent,
+			node.alternate,
+		].some(node => node.type === 'ConditionalExpression')) {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const ancestors = sourceCode.getAncestors(node).reverse();
+		const nestLevel = ancestors.findIndex(node => node.type !== 'ConditionalExpression');
+
+		if (nestLevel === 1 && !isParenthesized(node, sourceCode)) {
+			return {
+				node,
+				messageId: MESSAGE_ID_SHOULD_PARENTHESIZED,
+				fix: fixer => [
+					fixer.insertTextBefore(node, '('),
+					fixer.insertTextAfter(node, ')'),
+				],
+			};
+		}
+
+		// Nesting more than one level not allowed
+		if (nestLevel > 1) {
+			return {
+				node: nestLevel > 2 ? ancestors[nestLevel - 3] : node,
+				messageId: MESSAGE_ID_TOO_DEEP,
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow nested ternary expressions.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-new-array.js

@@ -0,0 +1,104 @@
+'use strict';
+const {isParenthesized, getStaticValue} = require('@eslint-community/eslint-utils');
+const needsSemicolon = require('./utils/needs-semicolon.js');
+const isNumber = require('./utils/is-number.js');
+const {isNewExpression} = require('./ast/index.js');
+
+const MESSAGE_ID_ERROR = 'error';
+const MESSAGE_ID_LENGTH = 'array-length';
+const MESSAGE_ID_ONLY_ELEMENT = 'only-element';
+const MESSAGE_ID_SPREAD = 'spread';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Do not use `new Array()`.',
+	[MESSAGE_ID_LENGTH]: 'The argument is the length of array.',
+	[MESSAGE_ID_ONLY_ELEMENT]: 'The argument is the only element of array.',
+	[MESSAGE_ID_SPREAD]: 'Spread the argument.',
+};
+
+function getProblem(context, node) {
+	if (
+		!isNewExpression(node, {
+			name: 'Array',
+			argumentsLength: 1,
+			allowSpreadElement: true,
+		})
+	) {
+		return;
+	}
+
+	const problem = {
+		node,
+		messageId: MESSAGE_ID_ERROR,
+	};
+
+	const [argumentNode] = node.arguments;
+
+	const {sourceCode} = context;
+	let text = sourceCode.getText(argumentNode);
+	if (isParenthesized(argumentNode, sourceCode)) {
+		text = `(${text})`;
+	}
+
+	const maybeSemiColon = needsSemicolon(sourceCode.getTokenBefore(node), sourceCode, '[')
+		? ';'
+		: '';
+
+	// We are not sure how many `arguments` passed
+	if (argumentNode.type === 'SpreadElement') {
+		problem.suggest = [
+			{
+				messageId: MESSAGE_ID_SPREAD,
+				fix: fixer => fixer.replaceText(node, `${maybeSemiColon}[${text}]`),
+			},
+		];
+		return problem;
+	}
+
+	const fromLengthText = `Array.from(${text === 'length' ? '{length}' : `{length: ${text}}`})`;
+	const scope = sourceCode.getScope(node);
+	if (isNumber(argumentNode, scope)) {
+		problem.fix = fixer => fixer.replaceText(node, fromLengthText);
+		return problem;
+	}
+
+	const onlyElementText = `${maybeSemiColon}[${text}]`;
+	const result = getStaticValue(argumentNode, scope);
+	if (result !== null && typeof result.value !== 'number') {
+		problem.fix = fixer => fixer.replaceText(node, onlyElementText);
+		return problem;
+	}
+
+	// We don't know the argument is number or not
+	problem.suggest = [
+		{
+			messageId: MESSAGE_ID_LENGTH,
+			fix: fixer => fixer.replaceText(node, fromLengthText),
+		},
+		{
+			messageId: MESSAGE_ID_ONLY_ELEMENT,
+			fix: fixer => fixer.replaceText(node, onlyElementText),
+		},
+	];
+	return problem;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	NewExpression(node) {
+		return getProblem(context, node);
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow `new Array()`.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};