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

package/rules/fix/rename-variable.js

@@ -0,0 +1,9 @@
+'use strict';
+const getVariableIdentifiers = require('../utils/get-variable-identifiers.js');
+const replaceReferenceIdentifier = require('./replace-reference-identifier.js');
+
+const renameVariable = (variable, name, fixer) =>
+	getVariableIdentifiers(variable)
+		.map(identifier => replaceReferenceIdentifier(identifier, name, fixer));
+
+module.exports = renameVariable;

package/rules/fix/replace-argument.js

@@ -0,0 +1,8 @@
+'use strict';
+const {getParenthesizedRange} = require('../utils/parentheses.js');
+
+function replaceArgument(fixer, node, text, sourceCode) {
+	return fixer.replaceTextRange(getParenthesizedRange(node, sourceCode), text);
+}
+
+module.exports = replaceArgument;

package/rules/fix/replace-node-or-token-and-spaces-before.js

@@ -0,0 +1,21 @@
+'use strict';
+const {getParentheses} = require('../utils/parentheses.js');
+
+function * replaceNodeOrTokenAndSpacesBefore(nodeOrToken, replacement, fixer, sourceCode, tokenStore = sourceCode) {
+	const tokens = getParentheses(nodeOrToken, tokenStore);
+
+	for (const token of tokens) {
+		yield * replaceNodeOrTokenAndSpacesBefore(token, '', fixer, sourceCode, tokenStore);
+	}
+
+	let [start, end] = nodeOrToken.range;
+
+	const textBefore = sourceCode.text.slice(0, start);
+	const [trailingSpaces] = textBefore.match(/\s*$/);
+	const [lineBreak] = trailingSpaces.match(/(?:\r?\n|\r){0,1}/);
+	start -= trailingSpaces.length;
+
+	yield fixer.replaceTextRange([start, end], `${lineBreak}${replacement}`);
+}
+
+module.exports = replaceNodeOrTokenAndSpacesBefore;

package/rules/fix/replace-reference-identifier.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const isShorthandPropertyValue = require('../utils/is-shorthand-property-value.js');
+const isShorthandPropertyAssignmentPatternLeft = require('../utils/is-shorthand-property-assignment-pattern-left.js');
+const isShorthandImportLocal = require('../utils/is-shorthand-import-local.js');
+const isShorthandExportLocal = require('../utils/is-shorthand-export-local.js');
+
+function replaceReferenceIdentifier(identifier, replacement, fixer) {
+	if (
+		isShorthandPropertyValue(identifier)
+		|| isShorthandPropertyAssignmentPatternLeft(identifier)
+	) {
+		return fixer.replaceText(identifier, `${identifier.name}: ${replacement}`);
+	}
+
+	if (isShorthandImportLocal(identifier)) {
+		return fixer.replaceText(identifier, `${identifier.name} as ${replacement}`);
+	}
+
+	if (isShorthandExportLocal(identifier)) {
+		return fixer.replaceText(identifier, `${replacement} as ${identifier.name}`);
+	}
+
+	// `typeAnnotation`
+	if (identifier.typeAnnotation) {
+		return fixer.replaceTextRange(
+			[identifier.range[0], identifier.typeAnnotation.range[0]],
+			`${replacement}${identifier.optional ? '?' : ''}`,
+		);
+	}
+
+	return fixer.replaceText(identifier, replacement);
+}
+
+module.exports = replaceReferenceIdentifier;

package/rules/fix/replace-string-literal.js

@@ -0,0 +1,11 @@
+'use strict';
+
+function replaceStringLiteral(fixer, node, text, relativeRangeStart, relativeRangeEnd) {
+	const firstCharacterIndex = node.range[0] + 1;
+	const start = Number.isInteger(relativeRangeEnd) ? relativeRangeStart + firstCharacterIndex : firstCharacterIndex;
+	const end = Number.isInteger(relativeRangeEnd) ? relativeRangeEnd + firstCharacterIndex : node.range[1] - 1;
+
+	return fixer.replaceTextRange([start, end], text);
+}
+
+module.exports = replaceStringLiteral;

package/rules/fix/replace-string-raw.js

@@ -0,0 +1,14 @@
+'use strict';
+
+// Replace `StringLiteral` or `TemplateLiteral` node with raw text
+const replaceStringRaw = (fixer, node, raw) =>
+	fixer.replaceTextRange(
+		// Ignore quotes and backticks
+		[
+			node.range[0] + 1,
+			node.range[1] - 1,
+		],
+		raw,
+	);
+
+module.exports = replaceStringRaw;

package/rules/fix/replace-template-element.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const replaceTemplateElement = (fixer, node, replacement) => {
+	const {range: [start, end], tail} = node;
+	return fixer.replaceTextRange(
+		[start + 1, end - (tail ? 1 : 2)],
+		replacement,
+	);
+};
+
+module.exports = replaceTemplateElement;

package/rules/fix/switch-call-expression-to-new-expression.js

@@ -0,0 +1,18 @@
+'use strict';
+const {isParenthesized} = require('../utils/parentheses.js');
+const shouldAddParenthesesToNewExpressionCallee = require('../utils/should-add-parentheses-to-new-expression-callee.js');
+
+function * switchCallExpressionToNewExpression(node, sourceCode, fixer) {
+	yield fixer.insertTextBefore(node, 'new ');
+
+	const {callee} = node;
+	if (
+		!isParenthesized(callee, sourceCode)
+		&& shouldAddParenthesesToNewExpressionCallee(callee)
+	) {
+		yield fixer.insertTextBefore(callee, '(');
+		yield fixer.insertTextAfter(callee, ')');
+	}
+}
+
+module.exports = switchCallExpressionToNewExpression;

package/rules/fix/switch-new-expression-to-call-expression.js

@@ -0,0 +1,34 @@
+'use strict';
+const isNewExpressionWithParentheses = require('../utils/is-new-expression-with-parentheses.js');
+const {isParenthesized} = require('../utils/parentheses.js');
+const isOnSameLine = require('../utils/is-on-same-line.js');
+const addParenthesizesToReturnOrThrowExpression = require('./add-parenthesizes-to-return-or-throw-expression.js');
+const removeSpaceAfter = require('./remove-spaces-after.js');
+
+function * switchNewExpressionToCallExpression(newExpression, sourceCode, fixer) {
+	const newToken = sourceCode.getFirstToken(newExpression);
+	yield fixer.remove(newToken);
+	yield removeSpaceAfter(newToken, sourceCode, fixer);
+
+	if (!isNewExpressionWithParentheses(newExpression, sourceCode)) {
+		yield fixer.insertTextAfter(newExpression, '()');
+	}
+
+	/*
+		Remove `new` from this code will makes the function return `undefined`
+
+		```js
+			() => {
+				return new // comment
+					Foo()
+			}
+		```
+	*/
+	if (!isOnSameLine(newToken, newExpression.callee) && !isParenthesized(newExpression, sourceCode)) {
+		// Ideally, we should use first parenthesis of the `callee`, and should check spaces after the `new` token
+		// But adding extra parentheses is harmless, no need to be too complicated
+		yield * addParenthesizesToReturnOrThrowExpression(fixer, newExpression.parent, sourceCode);
+	}
+}
+
+module.exports = switchNewExpressionToCallExpression;

package/rules/import-style.js

@@ -0,0 +1,364 @@
+'use strict';
+const {defaultsDeep} = require('./utils/lodash.js');
+const {getStringIfConstant} = require('@eslint-community/eslint-utils');
+const {isCallExpression} = require('./ast/index.js');
+
+const MESSAGE_ID = 'importStyle';
+const messages = {
+	[MESSAGE_ID]: 'Use {{allowedStyles}} import for module `{{moduleName}}`.',
+};
+
+const getActualImportDeclarationStyles = importDeclaration => {
+	const {specifiers} = importDeclaration;
+
+	if (specifiers.length === 0) {
+		return ['unassigned'];
+	}
+
+	const styles = new Set();
+
+	for (const specifier of specifiers) {
+		if (specifier.type === 'ImportDefaultSpecifier') {
+			styles.add('default');
+			continue;
+		}
+
+		if (specifier.type === 'ImportNamespaceSpecifier') {
+			styles.add('namespace');
+			continue;
+		}
+
+		if (specifier.type === 'ImportSpecifier') {
+			if (specifier.imported.type === 'Identifier' && specifier.imported.name === 'default') {
+				styles.add('default');
+				continue;
+			}
+
+			styles.add('named');
+			continue;
+		}
+	}
+
+	return [...styles];
+};
+
+const getActualExportDeclarationStyles = exportDeclaration => {
+	const {specifiers} = exportDeclaration;
+
+	if (specifiers.length === 0) {
+		return ['unassigned'];
+	}
+
+	const styles = new Set();
+
+	for (const specifier of specifiers) {
+		if (specifier.type === 'ExportSpecifier') {
+			if (specifier.exported.type === 'Identifier' && specifier.exported.name === 'default') {
+				styles.add('default');
+				continue;
+			}
+
+			styles.add('named');
+			continue;
+		}
+	}
+
+	return [...styles];
+};
+
+const getActualAssignmentTargetImportStyles = assignmentTarget => {
+	if (assignmentTarget.type === 'Identifier' || assignmentTarget.type === 'ArrayPattern') {
+		return ['namespace'];
+	}
+
+	if (assignmentTarget.type === 'ObjectPattern') {
+		if (assignmentTarget.properties.length === 0) {
+			return ['unassigned'];
+		}
+
+		const styles = new Set();
+
+		for (const property of assignmentTarget.properties) {
+			if (property.type === 'RestElement') {
+				styles.add('named');
+				continue;
+			}
+
+			if (property.key.type === 'Identifier') {
+				if (property.key.name === 'default') {
+					styles.add('default');
+				} else {
+					styles.add('named');
+				}
+			}
+		}
+
+		return [...styles];
+	}
+
+	// Next line is not test-coverable until unforceable changes to the language
+	// like an addition of new AST node types usable in `const __HERE__ = foo;`.
+	// An exotic custom parser or a bug in one could cover it too.
+	/* c8 ignore next */
+	return [];
+};
+
+const isAssignedDynamicImport = node =>
+	node.parent.type === 'AwaitExpression'
+	&& node.parent.argument === node
+	&& node.parent.parent.type === 'VariableDeclarator'
+	&& node.parent.parent.init === node.parent;
+
+// Keep this alphabetically sorted for easier maintenance
+const defaultStyles = {
+	chalk: {
+		default: true,
+	},
+	path: {
+		default: true,
+	},
+	util: {
+		named: true,
+	},
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	let [
+		{
+			styles = {},
+			extendDefaultStyles = true,
+			checkImport = true,
+			checkDynamicImport = true,
+			checkExportFrom = false,
+			checkRequire = true,
+		} = {},
+	] = context.options;
+
+	styles = extendDefaultStyles
+		? defaultsDeep({}, styles, defaultStyles)
+		: styles;
+
+	styles = new Map(
+		Object.entries(styles).map(
+			([moduleName, styles]) =>
+				[moduleName, new Set(Object.entries(styles).filter(([, isAllowed]) => isAllowed).map(([style]) => style))],
+		),
+	);
+
+	const {sourceCode} = context;
+
+	const report = (node, moduleName, actualImportStyles, allowedImportStyles, isRequire = false) => {
+		if (!allowedImportStyles || allowedImportStyles.size === 0) {
+			return;
+		}
+
+		let effectiveAllowedImportStyles = allowedImportStyles;
+
+		// For `require`, `'default'` style allows both `x = require('x')` (`'namespace'` style) and
+		// `{default: x} = require('x')` (`'default'` style) since we don't know in advance
+		// whether `'x'` is a compiled ES6 module (with `default` key) or a CommonJS module and `require`
+		// does not provide any automatic interop for this, so the user may have to use either of these.
+		if (isRequire && allowedImportStyles.has('default') && !allowedImportStyles.has('namespace')) {
+			effectiveAllowedImportStyles = new Set(allowedImportStyles);
+			effectiveAllowedImportStyles.add('namespace');
+		}
+
+		if (actualImportStyles.every(style => effectiveAllowedImportStyles.has(style))) {
+			return;
+		}
+
+		const data = {
+			allowedStyles: new Intl.ListFormat('en-US', {type: 'disjunction'}).format([...allowedImportStyles.keys()]),
+			moduleName,
+		};
+
+		context.report({
+			node,
+			messageId: MESSAGE_ID,
+			data,
+		});
+	};
+
+	if (checkImport) {
+		context.on('ImportDeclaration', node => {
+			const moduleName = getStringIfConstant(node.source, sourceCode.getScope(node.source));
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = getActualImportDeclarationStyles(node);
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+	}
+
+	if (checkDynamicImport) {
+		context.on('ImportExpression', node => {
+			if (isAssignedDynamicImport(node)) {
+				return;
+			}
+
+			const moduleName = getStringIfConstant(node.source, sourceCode.getScope(node.source));
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = ['unassigned'];
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+
+		context.on('VariableDeclarator', node => {
+			if (!(
+				node.init?.type === 'AwaitExpression'
+				&& node.init.argument.type === 'ImportExpression'
+			)) {
+				return;
+			}
+
+			const assignmentTargetNode = node.id;
+			const moduleNameNode = node.init.argument.source;
+			const moduleName = getStringIfConstant(moduleNameNode, sourceCode.getScope(moduleNameNode));
+
+			if (!moduleName) {
+				return;
+			}
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = getActualAssignmentTargetImportStyles(assignmentTargetNode);
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+	}
+
+	if (checkExportFrom) {
+		context.on('ExportAllDeclaration', node => {
+			const moduleName = getStringIfConstant(node.source, sourceCode.getScope(node.source));
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = ['namespace'];
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+
+		context.on('ExportNamedDeclaration', node => {
+			const moduleName = getStringIfConstant(node.source, sourceCode.getScope(node.source));
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = getActualExportDeclarationStyles(node);
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles);
+		});
+	}
+
+	if (checkRequire) {
+		context.on('CallExpression', node => {
+			if (!(
+				isCallExpression(node, {
+					name: 'require',
+					argumentsLength: 1,
+					optionalCall: false,
+					optionalMember: false,
+				})
+				&& (node.parent.type === 'ExpressionStatement' && node.parent.expression === node)
+			)) {
+				return;
+			}
+
+			const moduleName = getStringIfConstant(node.arguments[0], sourceCode.getScope(node.arguments[0]));
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = ['unassigned'];
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles, true);
+		});
+
+		context.on('VariableDeclarator', node => {
+			if (!(
+				node.init?.type === 'CallExpression'
+				&& node.init.callee.type === 'Identifier'
+				&& node.init.callee.name === 'require'
+			)) {
+				return;
+			}
+
+			const assignmentTargetNode = node.id;
+			const moduleNameNode = node.init.arguments[0];
+			const moduleName = getStringIfConstant(moduleNameNode, sourceCode.getScope(moduleNameNode));
+
+			if (!moduleName) {
+				return;
+			}
+
+			const allowedImportStyles = styles.get(moduleName);
+			const actualImportStyles = getActualAssignmentTargetImportStyles(assignmentTargetNode);
+
+			report(node, moduleName, actualImportStyles, allowedImportStyles, true);
+		});
+	}
+};
+
+const schema = {
+	type: 'array',
+	additionalItems: false,
+	items: [
+		{
+			type: 'object',
+			additionalProperties: false,
+			properties: {
+				checkImport: {
+					type: 'boolean',
+				},
+				checkDynamicImport: {
+					type: 'boolean',
+				},
+				checkExportFrom: {
+					type: 'boolean',
+				},
+				checkRequire: {
+					type: 'boolean',
+				},
+				extendDefaultStyles: {
+					type: 'boolean',
+				},
+				styles: {
+					$ref: '#/definitions/moduleStyles',
+				},
+			},
+		},
+	],
+	definitions: {
+		moduleStyles: {
+			type: 'object',
+			additionalProperties: {
+				$ref: '#/definitions/styles',
+			},
+		},
+		styles: {
+			anyOf: [
+				{
+					enum: [
+						false,
+					],
+				},
+				{
+					$ref: '#/definitions/booleanObject',
+				},
+			],
+		},
+		booleanObject: {
+			type: 'object',
+			additionalProperties: {
+				type: 'boolean',
+			},
+		},
+	},
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce specific import styles per module.',
+		},
+		schema,
+		messages,
+	},
+};

package/rules/new-for-builtins.js

@@ -0,0 +1,85 @@
+'use strict';
+const {GlobalReferenceTracker} = require('./utils/global-reference-tracker.js');
+const builtins = require('./utils/builtins.js');
+const {
+	switchCallExpressionToNewExpression,
+	switchNewExpressionToCallExpression,
+} = require('./fix/index.js');
+
+const messages = {
+	enforce: 'Use `new {{name}}()` instead of `{{name}}()`.',
+	disallow: 'Use `{{name}}()` instead of `new {{name}}()`.',
+};
+
+function enforceNewExpression({node, path: [name]}, sourceCode) {
+	if (name === 'Object') {
+		const {parent} = node;
+		if (
+			parent.type === 'BinaryExpression'
+			&& (parent.operator === '===' || parent.operator === '!==')
+			&& (parent.left === node || parent.right === node)
+		) {
+			return;
+		}
+	}
+
+	return {
+		node,
+		messageId: 'enforce',
+		data: {name},
+		fix: fixer => switchCallExpressionToNewExpression(node, sourceCode, fixer),
+	};
+}
+
+function enforceCallExpression({node, path: [name]}, sourceCode) {
+	const problem = {
+		node,
+		messageId: 'disallow',
+		data: {name},
+	};
+
+	if (name !== 'String' && name !== 'Boolean' && name !== 'Number') {
+		problem.fix = function * (fixer) {
+			yield * switchNewExpressionToCallExpression(node, sourceCode, fixer);
+		};
+	}
+
+	return problem;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const newExpressionTracker = new GlobalReferenceTracker({
+		objects: builtins.disallowNew,
+		type: GlobalReferenceTracker.CONSTRUCT,
+		handle: reference => enforceCallExpression(reference, sourceCode),
+	});
+	const callExpressionTracker = new GlobalReferenceTracker({
+		objects: builtins.enforceNew,
+		type: GlobalReferenceTracker.CALL,
+		handle: reference => enforceNewExpression(reference, sourceCode),
+	});
+
+	return {
+		* 'Program:exit'(program) {
+			const scope = sourceCode.getScope(program);
+
+			yield * newExpressionTracker.track(scope);
+			yield * callExpressionTracker.track(scope);
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce the use of `new` for all builtins, except `String`, `Number`, `Boolean`, `Symbol` and `BigInt`.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-abusive-eslint-disable.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const MESSAGE_ID = 'no-abusive-eslint-disable';
+const messages = {
+	[MESSAGE_ID]: 'Specify the rules you want to disable.',
+};
+
+const disableRegex = /^eslint-disable(?:-next-line|-line)?(?<ruleId>$|(?:\s+(?:@(?:[\w-]+\/){1,2})?[\w-]+)?)/;
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	* Program(node) {
+		for (const comment of node.comments) {
+			const value = comment.value.trim();
+			const result = disableRegex.exec(value);
+
+			if (
+				result // It's a eslint-disable comment
+				&& !result.groups.ruleId // But it did not specify any rules
+			) {
+				yield {
+					// Can't set it at the given location as the warning
+					// will be ignored due to the disable comment
+					loc: {
+						start: {
+							...comment.loc.start,
+							column: -1,
+						},
+						end: comment.loc.end,
+					},
+					messageId: MESSAGE_ID,
+				};
+			}
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce specifying rules to disable in `eslint-disable` comments.',
+		},
+		messages,
+	},
+};