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

package/rules/prefer-keyboard-event-key.js

@@ -0,0 +1,186 @@
+'use strict';
+const escapeString = require('./utils/escape-string.js');
+const translateToKey = require('./shared/event-keys.js');
+const {isNumberLiteral} = require('./ast/index.js');
+
+const MESSAGE_ID = 'prefer-keyboard-event-key';
+const messages = {
+	[MESSAGE_ID]: 'Use `.key` instead of `.{{name}}`.',
+};
+
+const keys = new Set([
+	'keyCode',
+	'charCode',
+	'which',
+]);
+
+const isPropertyNamedAddEventListener = node =>
+	node?.type === 'CallExpression'
+	&& node.callee.type === 'MemberExpression'
+	&& node.callee.property.name === 'addEventListener';
+
+const getEventNodeAndReferences = (context, node) => {
+	const eventListener = getMatchingAncestorOfType(node, 'CallExpression', isPropertyNamedAddEventListener);
+	const callback = eventListener?.arguments[1];
+	switch (callback?.type) {
+		case 'ArrowFunctionExpression':
+		case 'FunctionExpression': {
+			const eventVariable = context.sourceCode.getDeclaredVariables(callback)[0];
+			const references = eventVariable?.references;
+			return {
+				event: callback.params[0],
+				references,
+			};
+		}
+
+		default: {
+			return {};
+		}
+	}
+};
+
+const isPropertyOf = (node, eventNode) =>
+	node?.parent?.type === 'MemberExpression'
+	&& node.parent.object === eventNode;
+
+// The third argument is a condition function, as one passed to `Array#filter()`
+// Helpful if nearest node of type also needs to have some other property
+const getMatchingAncestorOfType = (node, type, testFunction = () => true) => {
+	let current = node;
+	while (current) {
+		if (current.type === type && testFunction(current)) {
+			return current;
+		}
+
+		current = current.parent;
+	}
+};
+
+const getParentByLevel = (node, level) => {
+	let current = node;
+	while (current && level) {
+		level--;
+		current = current.parent;
+	}
+
+	/* c8 ignore next 3 */
+	if (level === 0) {
+		return current;
+	}
+};
+
+const fix = node => fixer => {
+	// Since we're only fixing direct property access usages, like `event.keyCode`
+	const nearestIf = getParentByLevel(node, 3);
+	if (!nearestIf || nearestIf.type !== 'IfStatement') {
+		return;
+	}
+
+	const {type, operator, right} = nearestIf.test;
+	if (
+		!(
+			type === 'BinaryExpression'
+			&& (operator === '==' || operator === '===')
+			&& isNumberLiteral(right)
+		)
+	) {
+		return;
+	}
+
+	// Either a meta key or a printable character
+	const key = translateToKey[right.value] || String.fromCodePoint(right.value);
+	// And if we recognize the `.keyCode`
+	if (!key) {
+		return;
+	}
+
+	// Apply fixes
+	return [
+		fixer.replaceText(node, 'key'),
+		fixer.replaceText(right, escapeString(key)),
+	];
+};
+
+const getProblem = node => ({
+	messageId: MESSAGE_ID,
+	data: {name: node.name},
+	node,
+	fix: fix(node),
+});
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	Identifier(node) {
+		if (
+			node.name !== 'keyCode'
+			&& node.name !== 'charCode'
+			&& node.name !== 'which'
+		) {
+			return;
+		}
+
+		// Normal case when usage is direct -> `event.keyCode`
+		const {event, references} = getEventNodeAndReferences(context, node);
+		if (!event) {
+			return;
+		}
+
+		if (
+			references
+			&& references.some(reference => isPropertyOf(node, reference.identifier))
+		) {
+			return getProblem(node);
+		}
+	},
+
+	Property(node) {
+		// Destructured case
+		const propertyName = node.value.name;
+		if (!keys.has(propertyName)) {
+			return;
+		}
+
+		const {event, references} = getEventNodeAndReferences(context, node);
+		if (!event) {
+			return;
+		}
+
+		const nearestVariableDeclarator = getMatchingAncestorOfType(
+			node,
+			'VariableDeclarator',
+		);
+		const initObject = nearestVariableDeclarator?.init;
+
+		// Make sure initObject is a reference of eventVariable
+		if (
+			references
+			&& references.some(reference => reference.identifier === initObject)
+		) {
+			return getProblem(node.value);
+		}
+
+		// When the event parameter itself is destructured directly
+		const isEventParameterDestructured = event.type === 'ObjectPattern';
+		if (isEventParameterDestructured) {
+			// Check for properties
+			for (const property of event.properties) {
+				if (property === node) {
+					return getProblem(node.value);
+				}
+			}
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-logical-operator-over-ternary.js

@@ -0,0 +1,159 @@
+'use strict';
+const {isParenthesized, getParenthesizedText} = require('./utils/parentheses.js');
+const isSameReference = require('./utils/is-same-reference.js');
+const shouldAddParenthesesToLogicalExpressionChild = require('./utils/should-add-parentheses-to-logical-expression-child.js');
+const needsSemicolon = require('./utils/needs-semicolon.js');
+
+const MESSAGE_ID_ERROR = 'prefer-logical-operator-over-ternary/error';
+const MESSAGE_ID_SUGGESTION = 'prefer-logical-operator-over-ternary/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Prefer using a logical operator over a ternary.',
+	[MESSAGE_ID_SUGGESTION]: 'Switch to `{{operator}}` operator.',
+};
+
+function isSameNode(left, right, sourceCode) {
+	if (isSameReference(left, right)) {
+		return true;
+	}
+
+	if (left.type !== right.type) {
+		return false;
+	}
+
+	switch (left.type) {
+		case 'AwaitExpression': {
+			return isSameNode(left.argument, right.argument, sourceCode);
+		}
+
+		case 'LogicalExpression': {
+			return (
+				left.operator === right.operator
+				&& isSameNode(left.left, right.left, sourceCode)
+				&& isSameNode(left.right, right.right, sourceCode)
+			);
+		}
+
+		case 'UnaryExpression': {
+			return (
+				left.operator === right.operator
+				&& left.prefix === right.prefix
+				&& isSameNode(left.argument, right.argument, sourceCode)
+			);
+		}
+
+		case 'UpdateExpression': {
+			return false;
+		}
+
+		// No default
+	}
+
+	return sourceCode.getText(left) === sourceCode.getText(right);
+}
+
+function fix({
+	fixer,
+	sourceCode,
+	conditionalExpression,
+	left,
+	right,
+	operator,
+}) {
+	let text = [left, right].map((node, index) => {
+		const isNodeParenthesized = isParenthesized(node, sourceCode);
+		let text = isNodeParenthesized ? getParenthesizedText(node, sourceCode) : sourceCode.getText(node);
+
+		if (
+			!isNodeParenthesized
+			&& shouldAddParenthesesToLogicalExpressionChild(node, {operator, property: index === 0 ? 'left' : 'right'})
+		) {
+			text = `(${text})`;
+		}
+
+		return text;
+	}).join(` ${operator} `);
+
+	// According to https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#table
+	// There should be no cases need add parentheses when switching ternary to logical expression
+
+	// ASI
+	if (needsSemicolon(sourceCode.getTokenBefore(conditionalExpression), sourceCode, text)) {
+		text = `;${text}`;
+	}
+
+	return fixer.replaceText(conditionalExpression, text);
+}
+
+function getProblem({
+	sourceCode,
+	conditionalExpression,
+	left,
+	right,
+}) {
+	return {
+		node: conditionalExpression,
+		messageId: MESSAGE_ID_ERROR,
+		suggest: ['??', '||'].map(operator => ({
+			messageId: MESSAGE_ID_SUGGESTION,
+			data: {operator},
+			fix: fixer => fix({
+				fixer,
+				sourceCode,
+				conditionalExpression,
+				left,
+				right,
+				operator,
+			}),
+		})),
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	return {
+		ConditionalExpression(conditionalExpression) {
+			const {test, consequent, alternate} = conditionalExpression;
+
+			// `foo ? foo : bar`
+			if (isSameNode(test, consequent, sourceCode)) {
+				return getProblem({
+					sourceCode,
+					conditionalExpression,
+					left: test,
+					right: alternate,
+				});
+			}
+
+			// `!bar ? foo : bar`
+			if (
+				test.type === 'UnaryExpression'
+				&& test.operator === '!'
+				&& test.prefix
+				&& isSameNode(test.argument, alternate, sourceCode)
+			) {
+				return getProblem({
+					sourceCode,
+					conditionalExpression,
+					left: test.argument,
+					right: consequent,
+				});
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer using a logical operator over a ternary.',
+		},
+
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/prefer-math-trunc.js

@@ -0,0 +1,109 @@
+'use strict';
+const {hasSideEffect} = require('@eslint-community/eslint-utils');
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+const {isLiteral} = require('./ast/index.js');
+
+const ERROR_BITWISE = 'error-bitwise';
+const ERROR_BITWISE_NOT = 'error-bitwise-not';
+const SUGGESTION_BITWISE = 'suggestion-bitwise';
+const messages = {
+	[ERROR_BITWISE]: 'Use `Math.trunc` instead of `{{operator}} {{value}}`.',
+	[ERROR_BITWISE_NOT]: 'Use `Math.trunc` instead of `~~`.',
+	[SUGGESTION_BITWISE]: 'Replace `{{operator}} {{value}}` with `Math.trunc`.',
+};
+
+// Bitwise operators
+const bitwiseOperators = new Set(['|', '>>', '<<', '^']);
+const isBitwiseNot = node =>
+	node.type === 'UnaryExpression'
+	&& node.operator === '~';
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	const mathTruncFunctionCall = node => {
+		const text = sourceCode.getText(node);
+		const parenthesized = node.type === 'SequenceExpression' ? `(${text})` : text;
+		return `Math.trunc(${parenthesized})`;
+	};
+
+	context.on(['BinaryExpression', 'AssignmentExpression'], node => {
+		const {type, operator, right, left} = node;
+		const isAssignment = type === 'AssignmentExpression';
+		if (
+			!isLiteral(right, 0)
+			|| !bitwiseOperators.has(isAssignment ? operator.slice(0, -1) : operator)
+		) {
+			return;
+		}
+
+		const problem = {
+			node,
+			messageId: ERROR_BITWISE,
+			data: {
+				operator,
+				value: right.raw,
+			},
+		};
+
+		if (!isAssignment || !hasSideEffect(left, sourceCode)) {
+			const fix = function * (fixer) {
+				const fixed = mathTruncFunctionCall(left);
+				if (isAssignment) {
+					const operatorToken = sourceCode.getTokenAfter(left, token => token.type === 'Punctuator' && token.value === operator);
+					yield fixer.replaceText(operatorToken, '=');
+					yield fixer.replaceText(right, fixed);
+				} else {
+					yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
+					yield fixer.replaceText(node, fixed);
+				}
+			};
+
+			if (operator === '|') {
+				problem.suggest = [
+					{
+						messageId: SUGGESTION_BITWISE,
+						fix,
+					},
+				];
+			} else {
+				problem.fix = fix;
+			}
+		}
+
+		return problem;
+	});
+
+	// Unary Expression Selector: Inner-most 2 bitwise NOT
+	context.on('UnaryExpression', node => {
+		if (
+			isBitwiseNot(node)
+			&& isBitwiseNot(node.argument)
+			&& !isBitwiseNot(node.argument.argument)
+		) {
+			return {
+				node,
+				messageId: ERROR_BITWISE_NOT,
+				* fix(fixer) {
+					yield fixer.replaceText(node, mathTruncFunctionCall(node.argument.argument));
+					yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
+				},
+			};
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce the use of `Math.trunc` instead of bitwise operators.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/prefer-modern-dom-apis.js

@@ -0,0 +1,141 @@
+'use strict';
+const {isValueNotUsable} = require('./utils/index.js');
+const {isMethodCall} = require('./ast/index.js');
+
+const messages = {
+	replaceChildOrInsertBefore:
+		'Prefer `{{oldChildNode}}.{{preferredMethod}}({{newChildNode}})` over `{{parentNode}}.{{method}}({{newChildNode}}, {{oldChildNode}})`.',
+	insertAdjacentTextOrInsertAdjacentElement:
+		'Prefer `{{reference}}.{{preferredMethod}}({{content}})` over `{{reference}}.{{method}}({{position}}, {{content}})`.',
+};
+
+const disallowedMethods = new Map([
+	['replaceChild', 'replaceWith'],
+	['insertBefore', 'before'],
+]);
+
+const checkForReplaceChildOrInsertBefore = (context, node) => {
+	const method = node.callee.property.name;
+	const parentNode = node.callee.object.name;
+	const [newChildNode, oldChildNode] = node.arguments.map(({name}) => name);
+	const preferredMethod = disallowedMethods.get(method);
+
+	const fix = isValueNotUsable(node)
+		? fixer => fixer.replaceText(
+			node,
+			`${oldChildNode}.${preferredMethod}(${newChildNode})`,
+		)
+		: undefined;
+
+	return {
+		node,
+		messageId: 'replaceChildOrInsertBefore',
+		data: {
+			parentNode,
+			method,
+			preferredMethod,
+			newChildNode,
+			oldChildNode,
+		},
+		fix,
+	};
+};
+
+const positionReplacers = new Map([
+	['beforebegin', 'before'],
+	['afterbegin', 'prepend'],
+	['beforeend', 'append'],
+	['afterend', 'after'],
+]);
+
+const checkForInsertAdjacentTextOrInsertAdjacentElement = (context, node) => {
+	const method = node.callee.property.name;
+	const [positionNode, contentNode] = node.arguments;
+
+	const position = positionNode.value;
+	// Return early when specified position value of first argument is not a recognized value.
+	if (!positionReplacers.has(position)) {
+		return;
+	}
+
+	const preferredMethod = positionReplacers.get(position);
+	const {sourceCode} = context;
+	const content = sourceCode.getText(contentNode);
+	const reference = sourceCode.getText(node.callee.object);
+
+	const fix = method === 'insertAdjacentElement' && !isValueNotUsable(node)
+		? undefined
+		// TODO: make a better fix, don't touch reference
+		: fixer => fixer.replaceText(
+			node,
+			`${reference}.${preferredMethod}(${content})`,
+		);
+
+	return {
+		node,
+		messageId: 'insertAdjacentTextOrInsertAdjacentElement',
+		data: {
+			reference,
+			method,
+			preferredMethod,
+			position: sourceCode.getText(positionNode),
+			content,
+		},
+		fix,
+	};
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('CallExpression', node => {
+		if (
+			isMethodCall(node, {
+				methods: ['replaceChild', 'insertBefore'],
+				argumentsLength: 2,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// We only allow Identifier for now
+			&& node.arguments.every(node => node.type === 'Identifier' && node.name !== 'undefined')
+			// This check makes sure that only the first method of chained methods with same identifier name e.g: parentNode.insertBefore(alfa, beta).insertBefore(charlie, delta); gets reported
+			&& node.callee.object.type === 'Identifier'
+		) {
+			return checkForReplaceChildOrInsertBefore(context, node);
+		}
+	});
+
+	context.on('CallExpression', node => {
+		if (
+			isMethodCall(node, {
+				methods: ['insertAdjacentText', 'insertAdjacentElement'],
+				argumentsLength: 2,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// Position argument should be `string`
+			&& node.arguments[0].type === 'Literal'
+			// TODO: remove this limits on second argument
+			&& (
+				node.arguments[1].type === 'Literal'
+				|| node.arguments[1].type === 'Identifier'
+			)
+			// TODO: remove this limits on callee
+			&& node.callee.object.type === 'Identifier'
+		) {
+			return checkForInsertAdjacentTextOrInsertAdjacentElement(context, node);
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `.before()` over `.insertBefore()`, `.replaceWith()` over `.replaceChild()`, prefer one of `.before()`, `.after()`, `.append()` or `.prepend()` over `insertAdjacentText()` and `insertAdjacentElement()`.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};