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

package/rules/prefer-default-parameters.js

@@ -0,0 +1,219 @@
+'use strict';
+const {findVariable} = require('@eslint-community/eslint-utils');
+const {functionTypes} = require('./ast/index.js');
+
+const MESSAGE_ID = 'preferDefaultParameters';
+const MESSAGE_ID_SUGGEST = 'preferDefaultParametersSuggest';
+
+const isDefaultExpression = (left, right) =>
+	left
+	&& right
+	&& left.type === 'Identifier'
+	&& right.type === 'LogicalExpression'
+	&& (right.operator === '||' || right.operator === '??')
+	&& right.left.type === 'Identifier'
+	&& right.right.type === 'Literal';
+
+const containsCallExpression = (sourceCode, node) => {
+	if (!node) {
+		return false;
+	}
+
+	if (node.type === 'CallExpression') {
+		return true;
+	}
+
+	const keys = sourceCode.visitorKeys[node.type];
+
+	for (const key of keys) {
+		const value = node[key];
+
+		if (Array.isArray(value)) {
+			for (const element of value) {
+				if (containsCallExpression(sourceCode, element)) {
+					return true;
+				}
+			}
+		} else if (containsCallExpression(sourceCode, value)) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+const hasSideEffects = (sourceCode, function_, node) => {
+	for (const element of function_.body.body) {
+		if (element === node) {
+			break;
+		}
+
+		// Function call before default-assignment
+		if (containsCallExpression(sourceCode, element)) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+const hasExtraReferences = (assignment, references, left) => {
+	// Parameter is referenced prior to default-assignment
+	if (assignment && references[0].identifier !== left) {
+		return true;
+	}
+
+	// Old parameter is still referenced somewhere else
+	if (!assignment && references.length > 1) {
+		return true;
+	}
+
+	return false;
+};
+
+const isLastParameter = (parameters, parameter) => {
+	const lastParameter = parameters.at(-1);
+
+	// See 'default-param-last' rule
+	return parameter && parameter === lastParameter;
+};
+
+const needsParentheses = (sourceCode, function_) => {
+	if (function_.type !== 'ArrowFunctionExpression' || function_.params.length > 1) {
+		return false;
+	}
+
+	const [parameter] = function_.params;
+	const before = sourceCode.getTokenBefore(parameter);
+	const after = sourceCode.getTokenAfter(parameter);
+
+	return !after || !before || before.value !== '(' || after.value !== ')';
+};
+
+/** @param {import('eslint').Rule.RuleFixer} fixer */
+const fixDefaultExpression = (fixer, sourceCode, node) => {
+	const {line} = node.loc.start;
+	const {column} = node.loc.end;
+	const nodeText = sourceCode.getText(node);
+	const lineText = sourceCode.lines[line - 1];
+	const isOnlyNodeOnLine = lineText.trim() === nodeText;
+	const endsWithWhitespace = lineText[column] === ' ';
+
+	if (isOnlyNodeOnLine) {
+		return fixer.removeRange([
+			sourceCode.getIndexFromLoc({line, column: 0}),
+			sourceCode.getIndexFromLoc({line: line + 1, column: 0}),
+		]);
+	}
+
+	if (endsWithWhitespace) {
+		return fixer.removeRange([
+			node.range[0],
+			node.range[1] + 1,
+		]);
+	}
+
+	return fixer.remove(node);
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const functionStack = [];
+
+	const checkExpression = (node, left, right, assignment) => {
+		const currentFunction = functionStack.at(-1);
+
+		if (!currentFunction || !isDefaultExpression(left, right)) {
+			return;
+		}
+
+		const {name: firstId} = left;
+		const {
+			left: {name: secondId},
+			right: {raw: literal},
+		} = right;
+
+		// Parameter is reassigned to a different identifier
+		if (assignment && firstId !== secondId) {
+			return;
+		}
+
+		const variable = findVariable(sourceCode.getScope(node), secondId);
+
+		// This was reported https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1122
+		// But can't reproduce, just ignore this case
+		/* c8 ignore next 3 */
+		if (!variable) {
+			return;
+		}
+
+		const {references} = variable;
+		const {params} = currentFunction;
+		const parameter = params.find(parameter =>
+			parameter.type === 'Identifier'
+			&& parameter.name === secondId,
+		);
+
+		if (
+			hasSideEffects(sourceCode, currentFunction, node)
+			|| hasExtraReferences(assignment, references, left)
+			|| !isLastParameter(params, parameter)
+		) {
+			return;
+		}
+
+		const replacement = needsParentheses(sourceCode, currentFunction)
+			? `(${firstId} = ${literal})`
+			: `${firstId} = ${literal}`;
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			suggest: [{
+				messageId: MESSAGE_ID_SUGGEST,
+				fix: fixer => [
+					fixer.replaceText(parameter, replacement),
+					fixDefaultExpression(fixer, sourceCode, node),
+				],
+			}],
+		};
+	};
+
+	context.on(functionTypes, node => {
+		functionStack.push(node);
+	});
+
+	context.onExit(functionTypes, () => {
+		functionStack.pop();
+	});
+
+	context.on('AssignmentExpression', node => {
+		if (node.parent.type === 'ExpressionStatement' && node.parent.expression === node) {
+			return checkExpression(node.parent, node.left, node.right, true);
+		}
+	});
+
+	context.on('VariableDeclarator', node => {
+		if (node.parent.type === 'VariableDeclaration' && node.parent.declarations[0] === node) {
+			return checkExpression(node.parent, node.id, node.init, false);
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer default parameters over reassignment.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages: {
+			[MESSAGE_ID]: 'Prefer default parameters over reassignment.',
+			[MESSAGE_ID_SUGGEST]: 'Replace reassignment with default parameter.',
+		},
+	},
+};

package/rules/prefer-dom-node-append.js

@@ -0,0 +1,48 @@
+'use strict';
+const {isMethodCall} = require('./ast/index.js');
+const {isNodeValueNotDomNode, isValueNotUsable} = require('./utils/index.js');
+
+const MESSAGE_ID = 'prefer-dom-node-append';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `Node#append()` over `Node#appendChild()`.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	CallExpression(node) {
+		if (
+			!isMethodCall(node, {
+				method: 'appendChild',
+				argumentsLength: 1,
+				optionalCall: false,
+			})
+			|| isNodeValueNotDomNode(node.callee.object)
+			|| isNodeValueNotDomNode(node.arguments[0])
+		) {
+			return;
+		}
+
+		const fix = isValueNotUsable(node)
+			? fixer => fixer.replaceText(node.callee.property, 'append')
+			: undefined;
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			fix,
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `Node#append()` over `Node#appendChild()`.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-dom-node-dataset.js

@@ -0,0 +1,120 @@
+'use strict';
+const {isIdentifierName} = require('@babel/helper-validator-identifier');
+const {
+	escapeString,
+	hasOptionalChainElement,
+	isValueNotUsable,
+} = require('./utils/index.js');
+const {isMethodCall, isStringLiteral, isExpressionStatement} = require('./ast/index.js');
+
+const MESSAGE_ID = 'prefer-dom-node-dataset';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `.dataset` over `{{method}}(…)`.',
+};
+
+const dashToCamelCase = string => string.replaceAll(/-[a-z]/g, s => s[1].toUpperCase());
+
+function getFix(callExpression, context) {
+	const method = callExpression.callee.property.name;
+
+	// `foo?.bar = ''` is invalid
+	// TODO: Remove this restriction if https://github.com/nicolo-ribaudo/ecma262/pull/4 get merged
+	if (method === 'setAttribute' && hasOptionalChainElement(callExpression.callee)) {
+		return;
+	}
+
+	// `element.setAttribute(…)` returns `undefined`, but `AssignmentExpression` returns value of RHS
+	if (method === 'setAttribute' && !isValueNotUsable(callExpression)) {
+		return;
+	}
+
+	if (method === 'removeAttribute' && !isExpressionStatement(callExpression.parent)) {
+		return;
+	}
+
+	return fixer => {
+		const [nameNode] = callExpression.arguments;
+		const name = dashToCamelCase(nameNode.value.toLowerCase().slice(5));
+		const {sourceCode} = context;
+		let text = '';
+		const datasetText = `${sourceCode.getText(callExpression.callee.object)}.dataset`;
+		switch (method) {
+			case 'setAttribute':
+			case 'getAttribute':
+			case 'removeAttribute': {
+				text = isIdentifierName(name) ? `.${name}` : `[${escapeString(name, nameNode.raw.charAt(0))}]`;
+				text = `${datasetText}${text}`;
+				if (method === 'setAttribute') {
+					text += ` = ${sourceCode.getText(callExpression.arguments[1])}`;
+				} else if (method === 'removeAttribute') {
+					text = `delete ${text}`;
+				}
+
+				/*
+				For non-exists attribute, `element.getAttribute('data-foo')` returns `null`,
+				but `element.dataset.foo` returns `undefined`, switch to suggestions if necessary
+				*/
+				break;
+			}
+
+			case 'hasAttribute': {
+				text = `Object.hasOwn(${datasetText}, ${escapeString(name, nameNode.raw.charAt(0))})`;
+				break;
+			}
+			// No default
+		}
+
+		return fixer.replaceText(callExpression, text);
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(callExpression) {
+		if (!(
+			(
+				isMethodCall(callExpression, {
+					method: 'setAttribute',
+					argumentsLength: 2,
+					optionalCall: false,
+					optionalMember: false,
+				})
+				|| isMethodCall(callExpression, {
+					methods: ['getAttribute', 'removeAttribute', 'hasAttribute'],
+					argumentsLength: 1,
+					optionalCall: false,
+					optionalMember: false,
+				})
+			)
+			&& isStringLiteral(callExpression.arguments[0])
+		)) {
+			return;
+		}
+
+		const attributeName = callExpression.arguments[0].value.toLowerCase();
+
+		if (!attributeName.startsWith('data-')) {
+			return;
+		}
+
+		return {
+			node: callExpression,
+			messageId: MESSAGE_ID,
+			data: {method: callExpression.callee.property.name},
+			fix: getFix(callExpression, context),
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer using `.dataset` on DOM elements over calling attribute methods.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-dom-node-remove.js

@@ -0,0 +1,122 @@
+'use strict';
+const {isParenthesized, hasSideEffect} = require('@eslint-community/eslint-utils');
+const {isMethodCall} = require('./ast/index.js');
+const {
+	getParenthesizedText,
+	isNodeValueNotDomNode,
+	isValueNotUsable,
+	needsSemicolon,
+	shouldAddParenthesesToMemberExpressionObject,
+} = require('./utils/index.js');
+
+const ERROR_MESSAGE_ID = 'error';
+const SUGGESTION_MESSAGE_ID = 'suggestion';
+const messages = {
+	[ERROR_MESSAGE_ID]: 'Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`.',
+	[SUGGESTION_MESSAGE_ID]: 'Replace `parentNode.removeChild(childNode)` with `childNode{{dotOrQuestionDot}}remove()`.',
+};
+
+// TODO: Don't check node.type twice
+const isMemberExpressionOptionalObject = node =>
+	node.parent.type === 'MemberExpression'
+	&& node.parent.object === node
+	&& (
+		node.parent.optional
+		|| (node.type === 'MemberExpression' && isMemberExpressionOptionalObject(node.object))
+	);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	return {
+		CallExpression(node) {
+			if (
+				!isMethodCall(node, {
+					method: 'removeChild',
+					argumentsLength: 1,
+					optionalCall: false,
+				})
+				|| isNodeValueNotDomNode(node.callee.object)
+				|| isNodeValueNotDomNode(node.arguments[0])
+			) {
+				return;
+			}
+
+			const parentNode = node.callee.object;
+			const childNode = node.arguments[0];
+
+			const problem = {
+				node,
+				messageId: ERROR_MESSAGE_ID,
+			};
+
+			const isOptionalParentNode = isMemberExpressionOptionalObject(parentNode);
+
+			const createFix = (optional = false) => fixer => {
+				let childNodeText = getParenthesizedText(childNode, sourceCode);
+				if (
+					!isParenthesized(childNode, sourceCode)
+					&& shouldAddParenthesesToMemberExpressionObject(childNode, sourceCode)
+				) {
+					childNodeText = `(${childNodeText})`;
+				}
+
+				if (needsSemicolon(sourceCode.getTokenBefore(node), sourceCode, childNodeText)) {
+					childNodeText = `;${childNodeText}`;
+				}
+
+				return fixer.replaceText(node, `${childNodeText}${optional ? '?' : ''}.remove()`);
+			};
+
+			if (!hasSideEffect(parentNode, sourceCode) && isValueNotUsable(node)) {
+				if (!isOptionalParentNode) {
+					problem.fix = createFix(false);
+					return problem;
+				}
+
+				// The most common case `foo?.parentNode.remove(foo)`
+				// TODO: Allow case like `foo.bar?.parentNode.remove(foo.bar)`
+				if (
+					node.callee.type === 'MemberExpression'
+					&& !node.callee.optional
+					&& parentNode.type === 'MemberExpression'
+					&& parentNode.optional
+					&& !parentNode.computed
+					&& parentNode.property.type === 'Identifier'
+					&& parentNode.property.name === 'parentNode'
+					&& parentNode.object.type === 'Identifier'
+					&& childNode.type === 'Identifier'
+					&& parentNode.object.name === childNode.name
+				) {
+					problem.fix = createFix(true);
+					return problem;
+				}
+			}
+
+			problem.suggest = (
+				isOptionalParentNode ? [true, false] : [false]
+			).map(optional => ({
+				messageId: SUGGESTION_MESSAGE_ID,
+				data: {dotOrQuestionDot: optional ? '?.' : '.'},
+				fix: createFix(optional),
+			}));
+
+			return problem;
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/prefer-dom-node-text-content.js

@@ -0,0 +1,75 @@
+'use strict';
+const {isMemberExpression} = require('./ast/index.js');
+
+const ERROR = 'error';
+const SUGGESTION = 'suggestion';
+const messages = {
+	[ERROR]: 'Prefer `.textContent` over `.innerText`.',
+	[SUGGESTION]: 'Switch to `.textContent`.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	MemberExpression(memberExpression) {
+		if (
+			!isMemberExpression(memberExpression, {
+				property: 'innerText',
+			})
+		) {
+			return;
+		}
+
+		const node = memberExpression.property;
+
+		return {
+			node,
+			messageId: ERROR,
+			suggest: [
+				{
+					messageId: SUGGESTION,
+					fix: fixer => fixer.replaceText(node, 'textContent'),
+				},
+			],
+		};
+	},
+	Identifier(node) {
+		if (!(
+			node.name === 'innerText'
+			&& node.parent.type === 'Property'
+			&& node.parent.key === node
+			&& !node.parent.computed
+			&& node.parent.kind === 'init'
+			&& node.parent.parent.type === 'ObjectPattern'
+			&& node.parent.parent.properties.includes(node.parent)
+		)) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: ERROR,
+			suggest: [
+				{
+					messageId: SUGGESTION,
+					fix: fixer => fixer.replaceText(
+						node,
+						node.parent.shorthand ? 'textContent: innerText' : 'textContent',
+					),
+				},
+			],
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `.textContent` over `.innerText`.',
+		},
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/prefer-event-target.js

@@ -0,0 +1,117 @@
+'use strict';
+const {findVariable} = require('@eslint-community/eslint-utils');
+const {getAncestor} = require('./utils/index.js');
+const {isStaticRequire, isStringLiteral, isMemberExpression} = require('./ast/index.js');
+
+const MESSAGE_ID = 'prefer-event-target';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `EventTarget` over `EventEmitter`.',
+};
+
+const packagesShouldBeIgnored = new Set([
+	'@angular/core',
+	'eventemitter3',
+]);
+
+const isConstVariableDeclarationId = node =>
+	node.parent.type === 'VariableDeclarator'
+	&& node.parent.id === node
+	&& node.parent.parent.type === 'VariableDeclaration'
+	&& node.parent.parent.kind === 'const'
+	&& node.parent.parent.declarations.includes(node.parent);
+
+function isAwaitImportOrRequireFromIgnoredPackages(node) {
+	if (!node) {
+		return false;
+	}
+
+	let source;
+	if (isStaticRequire(node)) {
+		[source] = node.arguments;
+	} else if (node.type === 'AwaitExpression' && node.argument.type === 'ImportExpression') {
+		({source} = node.argument);
+	}
+
+	if (isStringLiteral(source) && packagesShouldBeIgnored.has(source.value)) {
+		return true;
+	}
+
+	return false;
+}
+
+function isFromIgnoredPackage(node) {
+	if (!node) {
+		return false;
+	}
+
+	const importDeclaration = getAncestor(node, 'ImportDeclaration');
+	if (packagesShouldBeIgnored.has(importDeclaration?.source.value)) {
+		return true;
+	}
+
+	// `const {EventEmitter} = ...`
+	if (
+		node.parent.type === 'Property'
+		&& node.parent.value === node
+		&& node.parent.key.type === 'Identifier'
+		&& node.parent.key.name === 'EventEmitter'
+		&& node.parent.parent.type === 'ObjectPattern'
+		&& node.parent.parent.properties.includes(node.parent)
+		&& isConstVariableDeclarationId(node.parent.parent)
+		&& isAwaitImportOrRequireFromIgnoredPackages(node.parent.parent.parent.init)
+	) {
+		return true;
+	}
+
+	// `const EventEmitter = (...).EventEmitter`
+	if (
+		isConstVariableDeclarationId(node)
+		&& isMemberExpression(node.parent.init, {property: 'EventEmitter', optional: false, computed: false})
+		&& isAwaitImportOrRequireFromIgnoredPackages(node.parent.init.object)
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	Identifier(node) {
+		if (!(
+			node.name === 'EventEmitter'
+			&& (
+				(
+					(node.parent.type === 'ClassDeclaration' || node.parent.type === 'ClassExpression')
+					&& node.parent.superClass === node
+				)
+				|| (node.parent.type === 'NewExpression' && node.parent.callee === node)
+			)
+		)) {
+			return;
+		}
+
+		const scope = context.sourceCode.getScope(node);
+		const variableNode = findVariable(scope, node)?.defs[0]?.name;
+		if (isFromIgnoredPackage(variableNode)) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `EventTarget` over `EventEmitter`.',
+		},
+		messages,
+	},
+};