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

package/rules/no-thenable.js

@@ -0,0 +1,198 @@
+'use strict';
+const {getStaticValue, getPropertyName} = require('@eslint-community/eslint-utils');
+const {isMethodCall} = require('./ast/index.js');
+
+const MESSAGE_ID_OBJECT = 'no-thenable-object';
+const MESSAGE_ID_EXPORT = 'no-thenable-export';
+const MESSAGE_ID_CLASS = 'no-thenable-class';
+const messages = {
+	[MESSAGE_ID_OBJECT]: 'Do not add `then` to an object.',
+	[MESSAGE_ID_EXPORT]: 'Do not export `then`.',
+	[MESSAGE_ID_CLASS]: 'Do not add `then` to a class.',
+};
+
+const isStringThen = (node, context) =>
+	getStaticValue(node, context.sourceCode.getScope(node))?.value === 'then';
+const isPropertyThen = (node, context) => {
+	// `getPropertyName` throws on `({[Symbol.prototype]: 0})`
+	// https://github.com/eslint-community/eslint-utils/pull/182
+	try {
+		return getPropertyName(node, context.sourceCode.getScope(node)) === 'then';
+	} catch {}
+
+	return false;
+};
+
+const cases = [
+	// `{then() {}}`,
+	// `{get then() {}}`,
+	// `{[computedKey]() {}}`,
+	// `{get [computedKey]() {}}`,
+	{
+		selector: 'ObjectExpression',
+		* getNodes(node, context) {
+			for (const property of node.properties) {
+				if (property.type === 'Property' && isPropertyThen(property, context)) {
+					yield property.key;
+				}
+			}
+		},
+		messageId: MESSAGE_ID_OBJECT,
+	},
+	// `class Foo {then}`,
+	// `class Foo {static then}`,
+	// `class Foo {get then() {}}`,
+	// `class Foo {static get then() {}}`,
+	{
+		selectors: ['PropertyDefinition', 'MethodDefinition'],
+		* getNodes(node, context) {
+			if (getPropertyName(node, context.sourceCode.getScope(node)) === 'then') {
+				yield node.key;
+			}
+		},
+		messageId: MESSAGE_ID_CLASS,
+	},
+	// `foo.then = …`
+	// `foo[computedKey] = …`
+	{
+		selector: 'MemberExpression',
+		* getNodes(node, context) {
+			if (!(node.parent.type === 'AssignmentExpression' && node.parent.left === node)) {
+				return;
+			}
+
+			if (getPropertyName(node, context.sourceCode.getScope(node)) === 'then') {
+				yield node.property;
+			}
+		},
+		messageId: MESSAGE_ID_OBJECT,
+	},
+	// `Object.defineProperty(foo, 'then', …)`
+	// `Reflect.defineProperty(foo, 'then', …)`
+	{
+		selector: 'CallExpression',
+		* getNodes(node, context) {
+			if (!(
+				isMethodCall(node, {
+					objects: ['Object', 'Reflect'],
+					method: 'defineProperty',
+					minimumArguments: 3,
+					optionalCall: false,
+					optionalMember: false,
+				})
+				&& node.arguments[0].type !== 'SpreadElement'
+			)) {
+				return;
+			}
+
+			const [, secondArgument] = node.arguments;
+			if (isStringThen(secondArgument, context)) {
+				yield secondArgument;
+			}
+		},
+		messageId: MESSAGE_ID_OBJECT,
+	},
+	// `Object.fromEntries([['then', …]])`
+	{
+		selector: 'CallExpression',
+		* getNodes(node, context) {
+			if (!(
+				isMethodCall(node, {
+					object: 'Object',
+					method: 'fromEntries',
+					argumentsLength: 1,
+					optionalCall: false,
+					optionalMember: false,
+				})
+				&& node.arguments[0].type === 'ArrayExpression'
+			)) {
+				return;
+			}
+
+			for (const pairs of node.arguments[0].elements) {
+				if (
+					pairs?.type === 'ArrayExpression'
+					&& pairs.elements[0]
+					&& pairs.elements[0].type !== 'SpreadElement'
+				) {
+					const [key] = pairs.elements;
+
+					if (isStringThen(key, context)) {
+						yield key;
+					}
+				}
+			}
+		},
+		messageId: MESSAGE_ID_OBJECT,
+	},
+	// `export {then}`
+	{
+		selector: 'Identifier',
+		* getNodes(node) {
+			if (
+				node.name === 'then'
+				&& node.parent.type === 'ExportSpecifier'
+				&& node.parent.exported === node
+			) {
+				yield node;
+			}
+		},
+		messageId: MESSAGE_ID_EXPORT,
+	},
+	// `export function then() {}`,
+	// `export class then {}`,
+	{
+		selector: 'Identifier',
+		* getNodes(node) {
+			if (
+				node.name === 'then'
+				&& (node.parent.type === 'FunctionDeclaration' || node.parent.type === 'ClassDeclaration')
+				&& node.parent.id === node
+				&& node.parent.parent.type === 'ExportNamedDeclaration'
+				&& node.parent.parent.declaration === node.parent
+			) {
+				yield node;
+			}
+		},
+		messageId: MESSAGE_ID_EXPORT,
+	},
+	// `export const … = …`;
+	{
+		selector: 'VariableDeclaration',
+		* getNodes(node, context) {
+			if (!(node.parent.type === 'ExportNamedDeclaration' && node.parent.declaration === node)) {
+				return;
+			}
+
+			for (const variable of context.sourceCode.getDeclaredVariables(node)) {
+				if (variable.name === 'then') {
+					yield * variable.identifiers;
+				}
+			}
+		},
+		messageId: MESSAGE_ID_EXPORT,
+	},
+];
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	for (const {selector, selectors, messageId, getNodes} of cases) {
+		context.on(selector ?? selectors, function * (node) {
+			for (const problematicNode of getNodes(node, context)) {
+				yield {node: problematicNode, messageId};
+			}
+		});
+	}
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow `then` property.',
+		},
+		messages,
+	},
+};

package/rules/no-this-assignment.js

@@ -0,0 +1,38 @@
+'use strict';
+const MESSAGE_ID = 'no-this-assignment';
+const messages = {
+	[MESSAGE_ID]: 'Do not assign `this` to `{{name}}`.',
+};
+
+function getProblem(variableNode, valueNode) {
+	if (
+		variableNode.type !== 'Identifier'
+		|| valueNode?.type !== 'ThisExpression'
+	) {
+		return;
+	}
+
+	return {
+		node: valueNode.parent,
+		data: {name: variableNode.name},
+		messageId: MESSAGE_ID,
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('VariableDeclarator', node => getProblem(node.id, node.init));
+	context.on('AssignmentExpression', node => getProblem(node.left, node.right));
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow assigning `this` to a variable.',
+		},
+		messages,
+	},
+};

package/rules/no-typeof-undefined.js

@@ -0,0 +1,143 @@
+'use strict';
+const {isLiteral} = require('./ast/index.js');
+const {
+	addParenthesizesToReturnOrThrowExpression,
+	removeSpacesAfter,
+} = require('./fix/index.js');
+const {
+	needsSemicolon,
+	isParenthesized,
+	isOnSameLine,
+	isShadowed,
+} = require('./utils/index.js');
+
+const MESSAGE_ID_ERROR = 'no-typeof-undefined/error';
+const MESSAGE_ID_SUGGESTION = 'no-typeof-undefined/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Compare with `undefined` directly instead of using `typeof`.',
+	[MESSAGE_ID_SUGGESTION]: 'Switch to `… {{operator}} undefined`.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {
+		checkGlobalVariables,
+	} = {
+		checkGlobalVariables: false,
+		...context.options[0],
+	};
+	const {sourceCode} = context;
+
+	return {
+		BinaryExpression(binaryExpression) {
+			if (!(
+				(
+					binaryExpression.operator === '==='
+					|| binaryExpression.operator === '!=='
+					|| binaryExpression.operator === '=='
+					|| binaryExpression.operator === '!='
+				)
+				&& binaryExpression.left.type === 'UnaryExpression'
+				&& binaryExpression.left.operator === 'typeof'
+				&& binaryExpression.left.prefix
+				&& isLiteral(binaryExpression.right, 'undefined')
+			)) {
+				return;
+			}
+
+			const {left: typeofNode, right: undefinedString, operator} = binaryExpression;
+
+			const valueNode = typeofNode.argument;
+			const isGlobalVariable = valueNode.type === 'Identifier'
+				&& !isShadowed(sourceCode.getScope(valueNode), valueNode);
+
+			if (!checkGlobalVariables && isGlobalVariable) {
+				return;
+			}
+
+			const [typeofToken, secondToken] = sourceCode.getFirstTokens(typeofNode, 2);
+
+			const fix = function * (fixer) {
+				// Change `==`/`!=` to `===`/`!==`
+				if (operator === '==' || operator === '!=') {
+					const operatorToken = sourceCode.getTokenAfter(
+						typeofNode,
+						token => token.type === 'Punctuator' && token.value === operator,
+					);
+
+					yield fixer.insertTextAfter(operatorToken, '=');
+				}
+
+				yield fixer.replaceText(undefinedString, 'undefined');
+
+				yield fixer.remove(typeofToken);
+				yield removeSpacesAfter(typeofToken, sourceCode, fixer);
+
+				const {parent} = binaryExpression;
+				if (
+					(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
+					&& parent.argument === binaryExpression
+					&& !isOnSameLine(typeofToken, secondToken)
+					&& !isParenthesized(binaryExpression, sourceCode)
+					&& !isParenthesized(typeofNode, sourceCode)
+				) {
+					yield * addParenthesizesToReturnOrThrowExpression(fixer, parent, sourceCode);
+					return;
+				}
+
+				const tokenBefore = sourceCode.getTokenBefore(binaryExpression);
+				if (needsSemicolon(tokenBefore, sourceCode, secondToken.value)) {
+					yield fixer.insertTextBefore(binaryExpression, ';');
+				}
+			};
+
+			const problem = {
+				node: binaryExpression,
+				loc: typeofToken.loc,
+				messageId: MESSAGE_ID_ERROR,
+			};
+
+			if (isGlobalVariable) {
+				problem.suggest = [
+					{
+						messageId: MESSAGE_ID_SUGGESTION,
+						data: {operator: operator.startsWith('!') ? '!==' : '==='},
+						fix,
+					},
+				];
+			} else {
+				problem.fix = fix;
+			}
+
+			return problem;
+		},
+	};
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			checkGlobalVariables: {
+				type: 'boolean',
+				default: false,
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow comparing `undefined` using `typeof`.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema,
+		messages,
+	},
+};

package/rules/no-unnecessary-await.js

@@ -0,0 +1,107 @@
+'use strict';
+const {
+	addParenthesizesToReturnOrThrowExpression,
+	removeSpacesAfter,
+} = require('./fix/index.js');
+const {isParenthesized} = require('./utils/parentheses.js');
+const needsSemicolon = require('./utils/needs-semicolon.js');
+const isOnSameLine = require('./utils/is-on-same-line.js');
+
+const MESSAGE_ID = 'no-unnecessary-await';
+const messages = {
+	[MESSAGE_ID]: 'Do not `await` non-promise value.',
+};
+
+function notPromise(node) {
+	switch (node.type) {
+		case 'ArrayExpression':
+		case 'ArrowFunctionExpression':
+		case 'AwaitExpression':
+		case 'BinaryExpression':
+		case 'ClassExpression':
+		case 'FunctionExpression':
+		case 'JSXElement':
+		case 'JSXFragment':
+		case 'Literal':
+		case 'TemplateLiteral':
+		case 'UnaryExpression':
+		case 'UpdateExpression': {
+			return true;
+		}
+
+		case 'SequenceExpression': {
+			return notPromise(node.expressions.at(-1));
+		}
+
+		// No default
+	}
+
+	return false;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	AwaitExpression(node) {
+		if (!notPromise(node.argument)) {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const awaitToken = sourceCode.getFirstToken(node);
+		const problem = {
+			node,
+			loc: awaitToken.loc,
+			messageId: MESSAGE_ID,
+		};
+
+		const valueNode = node.argument;
+		if (
+			// Removing `await` may change them to a declaration, if there is no `id` will cause SyntaxError
+			valueNode.type === 'FunctionExpression'
+			|| valueNode.type === 'ClassExpression'
+			// `+await +1` -> `++1`
+			|| (
+				node.parent.type === 'UnaryExpression'
+				&& valueNode.type === 'UnaryExpression'
+				&& node.parent.operator === valueNode.operator
+			)
+		) {
+			return problem;
+		}
+
+		return Object.assign(problem, {
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			* fix(fixer) {
+				if (
+					!isOnSameLine(awaitToken, valueNode)
+					&& !isParenthesized(node, sourceCode)
+				) {
+					yield * addParenthesizesToReturnOrThrowExpression(fixer, node.parent, sourceCode);
+				}
+
+				yield fixer.remove(awaitToken);
+				yield removeSpacesAfter(awaitToken, sourceCode, fixer);
+
+				const nextToken = sourceCode.getTokenAfter(awaitToken);
+				const tokenBefore = sourceCode.getTokenBefore(awaitToken);
+				if (needsSemicolon(tokenBefore, sourceCode, nextToken.value)) {
+					yield fixer.insertTextBefore(nextToken, ';');
+				}
+			},
+		});
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow awaiting non-promise values.',
+		},
+		fixable: 'code',
+
+		messages,
+	},
+};

package/rules/no-unnecessary-polyfills.js

@@ -0,0 +1,176 @@
+'use strict';
+const path = require('node:path');
+const readPkgUp = require('read-pkg-up');
+const coreJsCompat = require('core-js-compat');
+const {camelCase} = require('./utils/lodash.js');
+const isStaticRequire = require('./ast/is-static-require.js');
+
+const {data: compatData, entries: coreJsEntries} = coreJsCompat;
+
+const MESSAGE_ID_POLYFILL = 'unnecessaryPolyfill';
+const MESSAGE_ID_CORE_JS = 'unnecessaryCoreJsModule';
+const messages = {
+	[MESSAGE_ID_POLYFILL]: 'Use built-in instead.',
+	[MESSAGE_ID_CORE_JS]:
+		'All polyfilled features imported from `{{coreJsModule}}` are available as built-ins. Use the built-ins instead.',
+};
+
+const additionalPolyfillPatterns = {
+	'es.promise.finally': '|(p-finally)',
+	'es.object.set-prototype-of': '|(setprototypeof)',
+	'es.string.code-point-at': '|(code-point-at)',
+};
+
+const prefixes = '(mdn-polyfills/|polyfill-)';
+const suffixes = '(-polyfill)';
+const delimiter = '(\\.|-|\\.prototype\\.|/)?';
+
+const polyfills = Object.keys(compatData).map(feature => {
+	let [ecmaVersion, constructorName, methodName = ''] = feature.split('.');
+
+	if (ecmaVersion === 'es') {
+		ecmaVersion = '(es\\d*)';
+	}
+
+	constructorName = `(${constructorName}|${camelCase(constructorName)})`;
+	methodName &&= `(${methodName}|${camelCase(methodName)})`;
+
+	const methodOrConstructor = methodName || constructorName;
+
+	const patterns = [
+		`^((${prefixes}?(`,
+		methodName && `(${ecmaVersion}${delimiter}${constructorName}${delimiter}${methodName})|`, // Ex: es6-array-copy-within
+		methodName && `(${constructorName}${delimiter}${methodName})|`, // Ex: array-copy-within
+		`(${ecmaVersion}${delimiter}${constructorName}))`, // Ex: es6-array
+		`${suffixes}?)|`,
+		`(${prefixes}${methodOrConstructor}|${methodOrConstructor}${suffixes})`, // Ex: polyfill-copy-within / polyfill-promise
+		`${additionalPolyfillPatterns[feature] || ''})$`,
+	];
+
+	return {
+		feature,
+		pattern: new RegExp(patterns.join(''), 'i'),
+	};
+});
+
+function getTargets(options, dirname) {
+	if (options?.targets) {
+		return options.targets;
+	}
+
+	/** @type {readPkgUp.ReadResult | undefined} */
+	let packageResult;
+	try {
+		// It can fail if, for example, the package.json file has comments.
+		packageResult = readPkgUp.sync({normalize: false, cwd: dirname});
+	} catch {}
+
+	if (!packageResult) {
+		return;
+	}
+
+	const {browserlist, engines} = packageResult.packageJson;
+	return browserlist ?? engines;
+}
+
+function create(context) {
+	const targets = getTargets(context.options[0], path.dirname(context.filename));
+	if (!targets) {
+		return {};
+	}
+
+	let unavailableFeatures;
+	try {
+		unavailableFeatures = coreJsCompat({targets}).list;
+	} catch {
+		// This can happen if the targets are invalid or use unsupported syntax like `{node:'*'}`.
+		return {};
+	}
+
+	const checkFeatures = features => !features.every(feature => unavailableFeatures.includes(feature));
+
+	return {
+		Literal(node) {
+			if (
+				!(
+					(['ImportDeclaration', 'ImportExpression'].includes(node.parent.type) && node.parent.source === node)
+					|| (isStaticRequire(node.parent) && node.parent.arguments[0] === node)
+				)
+			) {
+				return;
+			}
+
+			const importedModule = node.value;
+			if (typeof importedModule !== 'string' || ['.', '/'].includes(importedModule[0])) {
+				return;
+			}
+
+			const coreJsModuleFeatures = coreJsEntries[importedModule.replace('core-js-pure', 'core-js')];
+
+			if (coreJsModuleFeatures) {
+				if (coreJsModuleFeatures.length > 1) {
+					if (checkFeatures(coreJsModuleFeatures)) {
+						return {
+							node,
+							messageId: MESSAGE_ID_CORE_JS,
+							data: {
+								coreJsModule: importedModule,
+							},
+						};
+					}
+				} else if (!unavailableFeatures.includes(coreJsModuleFeatures[0])) {
+					return {node, messageId: MESSAGE_ID_POLYFILL};
+				}
+
+				return;
+			}
+
+			const polyfill = polyfills.find(({pattern}) => pattern.test(importedModule));
+			if (polyfill) {
+				const [, namespace, method = ''] = polyfill.feature.split('.');
+				const [, features] = Object.entries(coreJsEntries).find(
+					entry => entry[0] === `core-js/full/${namespace}${method && '/'}${method}`,
+				);
+				if (checkFeatures(features)) {
+					return {node, messageId: MESSAGE_ID_POLYFILL};
+				}
+			}
+		},
+	};
+}
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		required: ['targets'],
+		properties: {
+			targets: {
+				oneOf: [
+					{
+						type: 'string',
+					},
+					{
+						type: 'array',
+					},
+					{
+						type: 'object',
+					},
+				],
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce the use of built-in methods instead of unnecessary polyfills.',
+		},
+		schema,
+		messages,
+	},
+};